@graphql-eslint/eslint-plugin 4.0.0-alpha-20230801163310-8bc4340 → 4.0.0-alpha-20230810155929-e89edf7

package/cjs/rules/unique-fragment-name.js

@@ -5,58 +5,45 @@ 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") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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 });
-  }
+      !__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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var unique_fragment_name_exports = {};
 __export(unique_fragment_name_exports, {
   checkNode: () => checkNode,
   rule: () => rule
 });
 module.exports = __toCommonJS(unique_fragment_name_exports);
-var import_path = require("path");
-var import_graphql = require("graphql");
-var import_utils = require("../utils.js");
-const RULE_ID = "unique-fragment-name";
-const checkNode = (context, node, ruleId) => {
-  const documentName = node.name.value;
-  const siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context);
-  const siblingDocuments = node.kind === import_graphql.Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName);
-  const filepath = context.getFilename();
-  const conflictingDocuments = siblingDocuments.filter((f) => {
-    var _a;
-    const isSameName = ((_a = f.document.name) == null ? void 0 : _a.value) === documentName;
-    const isSamePath = (0, import_utils.normalizePath)(f.filePath) === (0, import_utils.normalizePath)(filepath);
+var import_node_path = require("node:path"), import_graphql = require("graphql"), import_utils = require("../utils.js");
+const RULE_ID = "unique-fragment-name", checkNode = (context, node, ruleId) => {
+  const documentName = node.name.value, siblings = (0, import_utils.requireSiblingsOperations)(ruleId, context), siblingDocuments = node.kind === import_graphql.Kind.FRAGMENT_DEFINITION ? siblings.getFragment(documentName) : siblings.getOperation(documentName), filepath = context.filename, conflictingDocuments = siblingDocuments.filter((f) => {
+    const isSameName = f.document.name?.value === documentName, isSamePath = (0, import_utils.normalizePath)(f.filePath) === (0, import_utils.normalizePath)(filepath);
     return isSameName && !isSamePath;
   });
-  if (conflictingDocuments.length > 0) {
-    context.report({
-      messageId: ruleId,
-      data: {
-        documentName,
-        summary: conflictingDocuments.map((f) => `	${(0, import_path.relative)(import_utils.CWD, f.filePath.replace(import_utils.VIRTUAL_DOCUMENT_REGEX, ""))}`).join("\n")
-      },
-      // @ts-expect-error name will exist
-      node: node.name
-    });
-  }
-};
-const rule = {
+  conflictingDocuments.length > 0 && context.report({
+    messageId: ruleId,
+    data: {
+      documentName,
+      summary: conflictingDocuments.map((f) => `	${(0, import_node_path.relative)(import_utils.CWD, f.filePath.replace(import_utils.VIRTUAL_DOCUMENT_REGEX, ""))}`).join(`
+`)
+    },
+    // @ts-expect-error name will exist
+    node: node.name
+  });
+}, rule = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique fragment names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSiblings: true,
+      requiresSiblings: !0,
+      recommended: !0,
       examples: [
         {
           title: "Incorrect",
@@ -99,7 +86,8 @@ const rule = {
       ]
     },
     messages: {
-      [RULE_ID]: 'Fragment named "{{ documentName }}" already defined in:\n{{ summary }}'
+      [RULE_ID]: `Fragment named "{{ documentName }}" already defined in:
+{{ summary }}`
     },
     schema: []
   },

package/cjs/rules/unique-operation-name.d.ts

@@ -1,11 +1,12 @@
-import { f as GraphQLESLintRule } from '../types-8d5f4ae0.js';
-import '@graphql-tools/utils';
+import { GraphQLESLintRule } from '../types.js';
 import 'eslint';
 import 'estree';
 import 'graphql';
-import 'graphql-config';
 import 'json-schema-to-ts';
+import '../siblings.js';
+import '@graphql-tools/utils';
 import '../estree-converter/types.js';
+import 'graphql-config';
 
 declare const rule: GraphQLESLintRule;
 

package/cjs/rules/unique-operation-name.js

@@ -5,32 +5,29 @@ 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") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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 });
-  }
+      !__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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var unique_operation_name_exports = {};
 __export(unique_operation_name_exports, {
   rule: () => rule
 });
 module.exports = __toCommonJS(unique_operation_name_exports);
 var import_unique_fragment_name = require("./unique-fragment-name.js");
-const RULE_ID = "unique-operation-name";
-const rule = {
+const RULE_ID = "unique-operation-name", rule = {
   meta: {
     type: "suggestion",
     docs: {
       category: "Operations",
       description: "Enforce unique operation names across your project.",
       url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-      requiresSiblings: true,
+      requiresSiblings: !0,
+      recommended: !0,
       examples: [
         {
           title: "Incorrect",
@@ -77,7 +74,8 @@ const rule = {
       ]
     },
     messages: {
-      [RULE_ID]: 'Operation named "{{ documentName }}" already defined in:\n{{ summary }}'
+      [RULE_ID]: `Operation named "{{ documentName }}" already defined in:
+{{ summary }}`
     },
     schema: []
   },

package/cjs/schema.d.ts

@@ -1,12 +1,13 @@
 import { GraphQLProjectConfig } from 'graphql-config';
-import { P as ParserOptions, S as Schema } from './types-8d5f4ae0.js';
-import '@graphql-tools/utils';
+import { Schema } from './types.js';
 import 'eslint';
 import 'estree';
 import 'graphql';
 import 'json-schema-to-ts';
+import './siblings.js';
+import '@graphql-tools/utils';
 import './estree-converter/types.js';
 
-declare function getSchema(project: GraphQLProjectConfig, schemaOptions?: ParserOptions['schemaOptions']): Schema;
+declare function getSchema(project: GraphQLProjectConfig): Schema;
 
 export { getSchema };

package/cjs/schema.js

@@ -3,18 +3,14 @@ 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 __getProtoOf = Object.getPrototypeOf, __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") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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 });
-  }
+      !__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(
@@ -22,42 +18,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   // 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,
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
   mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var schema_exports = {};
 __export(schema_exports, {
   getSchema: () => getSchema
 });
 module.exports = __toCommonJS(schema_exports);
-var import_debug = __toESM(require("debug"));
-var import_fast_glob = __toESM(require("fast-glob"));
-var import_graphql = require("graphql");
-var import_cache = require("./cache.js");
-const schemaCache = new import_cache.ModuleCache();
-const debug = (0, import_debug.default)("graphql-eslint:schema");
-function getSchema(project, schemaOptions) {
+var import_debug = __toESM(require("debug")), import_fast_glob = __toESM(require("fast-glob")), import_graphql = require("graphql"), import_cache = require("./cache.js");
+const schemaCache = new import_cache.ModuleCache(), debug = (0, import_debug.default)("graphql-eslint:schema");
+function getSchema(project) {
   const schemaKey = project.schema;
-  if (!schemaKey) {
+  if (!schemaKey)
     return null;
-  }
   const cache = schemaCache.get(schemaKey);
-  if (cache) {
+  if (cache)
     return cache;
-  }
   debug("Loading schema from %o", project.schema);
   const schema = project.loadSchemaSync(project.schema, "GraphQLSchema", {
-    ...schemaOptions,
     pluckConfig: project.extensions.pluckConfig
   });
   if (debug.enabled) {
     debug("Schema loaded: %o", schema instanceof import_graphql.GraphQLSchema);
-    const schemaPaths = import_fast_glob.default.sync(project.schema, { absolute: true });
+    const schemaPaths = import_fast_glob.default.sync(project.schema, { absolute: !0 });
     debug("Schema pointers %O", schemaPaths);
   }
-  schemaCache.set(schemaKey, schema);
-  return schema;
+  return schemaCache.set(schemaKey, schema), schema;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/cjs/siblings.d.ts

@@ -1,8 +1,24 @@
-import 'graphql';
-import 'graphql-config';
-export { F as FragmentSource, h as OperationSource, g as SiblingOperations, i as getSiblings } from './types-8d5f4ae0.js';
-import '@graphql-tools/utils';
-import 'eslint';
-import 'estree';
-import 'json-schema-to-ts';
-import './estree-converter/types.js';
+import { Source } from '@graphql-tools/utils';
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode } from 'graphql';
+
+type FragmentSource = {
+    filePath: string;
+    document: FragmentDefinitionNode;
+};
+type OperationSource = {
+    filePath: string;
+    document: OperationDefinitionNode;
+};
+type SiblingOperations = {
+    available: boolean;
+    getFragment(fragmentName: string): FragmentSource[];
+    getFragments(): FragmentSource[];
+    getFragmentByType(typeName: string): FragmentSource[];
+    getFragmentsInUse(baseOperation: FragmentDefinitionNode | OperationDefinitionNode | SelectionSetNode, recursive?: boolean): FragmentDefinitionNode[];
+    getOperation(operationName: string): OperationSource[];
+    getOperations(): OperationSource[];
+    getOperationByType(operationType: OperationTypeNode): OperationSource[];
+};
+declare function getSiblings(documents: Source[]): SiblingOperations;
+
+export { FragmentSource, OperationSource, SiblingOperations, getSiblings };

package/cjs/siblings.js

@@ -5,42 +5,29 @@ 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") {
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __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 });
-  }
+      !__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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var siblings_exports = {};
 __export(siblings_exports, {
   getSiblings: () => getSiblings
 });
 module.exports = __toCommonJS(siblings_exports);
-var import_utils = require("@graphql-tools/utils");
-var import_graphql = require("graphql");
-var import_documents = require("./documents.js");
-var import_utils2 = require("./utils.js");
+var import_graphql = require("graphql"), import_utils2 = require("./utils.js");
 const siblingOperationsCache = /* @__PURE__ */ new Map();
-function getSiblings(project, documents) {
-  const siblings = project ? (0, import_documents.getDocuments)(project) : typeof documents === "string" ? [(0, import_utils.parseGraphQLSDL)("operation.graphql", documents, { noLocation: true })] : [];
-  if (siblings.length === 0) {
-    let printed = false;
-    const noopWarn = () => {
-      if (!printed) {
-        import_utils2.logger.warn(
-          'getSiblingOperations was called without any operations. Make sure to set "parserOptions.operations" to make this feature available!'
-        );
-        printed = true;
-      }
-      return [];
-    };
+function getSiblings(documents) {
+  if (documents.length === 0) {
+    let printed = !1;
+    const noopWarn = () => (printed || (import_utils2.logger.warn(
+      "getSiblingOperations was called without any operations. Make sure to set graphql-config `documents` field to make this feature available! See https://the-guild.dev/graphql/config/docs/user/documents for more info"
+    ), printed = !0), []);
     return {
-      available: false,
+      available: !1,
       getFragment: noopWarn,
       getFragments: noopWarn,
       getFragmentByType: noopWarn,
@@ -50,85 +37,58 @@ function getSiblings(project, documents) {
       getOperationByType: noopWarn
     };
   }
-  const value = siblingOperationsCache.get(siblings);
-  if (value) {
+  const value = siblingOperationsCache.get(documents);
+  if (value)
     return value;
-  }
   let fragmentsCache = null;
   const getFragments = () => {
-    var _a;
     if (fragmentsCache === null) {
       const result = [];
-      for (const source of siblings) {
-        for (const definition of ((_a = source.document) == null ? void 0 : _a.definitions) || []) {
-          if (definition.kind === import_graphql.Kind.FRAGMENT_DEFINITION) {
-            result.push({
-              filePath: source.location,
-              document: definition
-            });
-          }
-        }
-      }
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === import_graphql.Kind.FRAGMENT_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
       fragmentsCache = result;
     }
     return fragmentsCache;
   };
   let cachedOperations = null;
   const getOperations = () => {
-    var _a;
     if (cachedOperations === null) {
       const result = [];
-      for (const source of siblings) {
-        for (const definition of ((_a = source.document) == null ? void 0 : _a.definitions) || []) {
-          if (definition.kind === import_graphql.Kind.OPERATION_DEFINITION) {
-            result.push({
-              filePath: source.location,
-              document: definition
-            });
-          }
-        }
-      }
+      for (const source of documents)
+        for (const definition of source.document?.definitions || [])
+          definition.kind === import_graphql.Kind.OPERATION_DEFINITION && result.push({
+            filePath: source.location,
+            document: definition
+          });
       cachedOperations = result;
     }
     return cachedOperations;
-  };
-  const getFragment = (name) => getFragments().filter((f) => f.document.name.value === name);
-  const collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => {
-    (0, import_graphql.visit)(selectable, {
-      FragmentSpread(spread) {
-        const fragmentName = spread.name.value;
-        const [fragment] = getFragment(fragmentName);
-        if (!fragment) {
-          import_utils2.logger.warn(
-            `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
-          );
-          return;
-        }
-        if (!collected.has(fragmentName)) {
-          collected.set(fragmentName, fragment.document);
-          if (recursive) {
-            collectFragments(fragment.document, recursive, collected);
-          }
-        }
+  }, getFragment = (name) => getFragments().filter((f) => f.document.name.value === name), collectFragments = (selectable, recursive, collected = /* @__PURE__ */ new Map()) => ((0, import_graphql.visit)(selectable, {
+    FragmentSpread(spread) {
+      const fragmentName = spread.name.value, [fragment] = getFragment(fragmentName);
+      if (!fragment) {
+        import_utils2.logger.warn(
+          `Unable to locate fragment named "${fragmentName}", please make sure it's loaded using "parserOptions.operations"`
+        );
+        return;
       }
-    });
-    return collected;
-  };
-  const siblingOperations = {
-    available: true,
+      collected.has(fragmentName) || (collected.set(fragmentName, fragment.document), recursive && collectFragments(fragment.document, recursive, collected));
+    }
+  }), collected), siblingOperations = {
+    available: !0,
     getFragment,
     getFragments,
     getFragmentByType: (typeName) => getFragments().filter((f) => f.document.typeCondition.name.value === typeName),
-    getFragmentsInUse: (selectable, recursive = true) => Array.from(collectFragments(selectable, recursive).values()),
-    getOperation: (name) => getOperations().filter((o) => {
-      var _a;
-      return ((_a = o.document.name) == null ? void 0 : _a.value) === name;
-    }),
+    getFragmentsInUse: (selectable, recursive = !0) => Array.from(collectFragments(selectable, recursive).values()),
+    getOperation: (name) => getOperations().filter((o) => o.document.name?.value === name),
     getOperations,
     getOperationByType: (type) => getOperations().filter((o) => o.document.operation === type)
   };
-  siblingOperationsCache.set(siblings, siblingOperations);
-  return siblingOperations;
+  return siblingOperationsCache.set(documents, siblingOperations), siblingOperations;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/cjs/types.d.ts

@@ -1,8 +1,75 @@
+import { Linter, Rule, AST } from 'eslint';
+import * as ESTree from 'estree';
+import { GraphQLSchema, ASTKindToNode } from 'graphql';
+import { JSONSchema } from 'json-schema-to-ts';
+import { SiblingOperations } from './siblings.js';
+import { GraphQLESTreeNode } from './estree-converter/types.js';
+import { IGraphQLConfig } from 'graphql-config';
 import '@graphql-tools/utils';
-import 'eslint';
-import 'estree';
-import 'graphql';
-import 'graphql-config';
-import 'json-schema-to-ts';
-export { C as CategoryType, G as GraphQLESLintParseResult, f as GraphQLESLintRule, c as GraphQLESLintRuleContext, e as GraphQLESLintRuleListener, O as OmitRecursively, P as ParserOptions, b as ParserServices, a as Pointer, R as ReportDescriptor, d as RuleDocsInfo, S as Schema, V as ValueOf } from './types-8d5f4ae0.js';
-import './estree-converter/types.js';
+
+type Schema = GraphQLSchema | null;
+type Pointer = string | string[];
+interface ParserOptions {
+    graphQLConfig?: IGraphQLConfig;
+    filePath: string;
+}
+type ParserServices = {
+    schema: Schema;
+    siblingOperations: SiblingOperations;
+};
+type GraphQLESLintParseResult = Linter.ESLintParseResult & {
+    services: ParserServices;
+};
+type Location = AST.SourceLocation | ESTree.Position;
+type ReportDescriptorLocation = {
+    loc: Location;
+} | {
+    node: {
+        loc: Location;
+    };
+};
+type ReportDescriptor = ReportDescriptorLocation & Rule.ReportDescriptorMessage & Rule.ReportDescriptorOptions;
+type GraphQLESLintRuleContext<Options = any[]> = Omit<Rule.RuleContext, 'options' | 'parserServices' | 'report'> & {
+    options: Options;
+    parserServices: ParserServices;
+    report(descriptor: ReportDescriptor): void;
+};
+type CategoryType = 'Operations' | 'Schema';
+type RuleMetaDataDocs = Required<Rule.RuleMetaData>['docs'];
+type RuleDocsInfo<T> = Omit<RuleMetaDataDocs, 'category' | 'suggestion'> & {
+    category: CategoryType | CategoryType[];
+    requiresSchema?: true;
+    requiresSiblings?: true;
+    examples?: {
+        title: string;
+        code: string;
+        usage?: T;
+    }[];
+    configOptions?: T | {
+        schema?: T;
+        operations?: T;
+    };
+    graphQLJSRuleName?: string;
+    isDisabledForAllConfig?: true;
+};
+type GraphQLESLintRuleListener<WithTypeInfo extends boolean = false> = Record<string, any> & {
+    [K in keyof ASTKindToNode]?: (node: GraphQLESTreeNode<ASTKindToNode[K], WithTypeInfo>) => void;
+};
+type GraphQLESLintRule<Options = [], WithTypeInfo extends boolean = false> = {
+    meta: Omit<Rule.RuleMetaData, 'docs' | 'schema'> & {
+        docs?: RuleDocsInfo<Options>;
+        schema: Readonly<JSONSchema> | [];
+    };
+    create(context: GraphQLESLintRuleContext<Options>): GraphQLESLintRuleListener<WithTypeInfo>;
+};
+type ValueOf<T> = T[keyof T];
+type Id<T> = {
+    [P in keyof T]: T[P];
+} & {};
+type OmitDistributive<T, K extends PropertyKey> = T extends object ? Id<OmitRecursively<T, K>> : T;
+type OmitRecursively<T extends object, K extends PropertyKey> = Omit<{
+    [P in keyof T]: OmitDistributive<T[P], K>;
+}, K>;
+type ConfigName = 'operations-all' | 'operations-recommended' | 'schema-all' | 'schema-recommended' | 'schema-relay';
+
+export { CategoryType, ConfigName, GraphQLESLintParseResult, GraphQLESLintRule, GraphQLESLintRuleContext, GraphQLESLintRuleListener, OmitRecursively, ParserOptions, ParserServices, Pointer, ReportDescriptor, RuleDocsInfo, Schema, ValueOf };

package/cjs/types.js

@@ -4,13 +4,11 @@ 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") {
+  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 });
-  }
+      !__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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var types_exports = {};
 module.exports = __toCommonJS(types_exports);

package/cjs/utils.d.ts

@@ -1,11 +1,12 @@
 import { AST } from 'eslint';
 import { Position } from 'estree';
 import { GraphQLSchema, ASTNode, Kind } from 'graphql';
-import { c as GraphQLESLintRuleContext, g as SiblingOperations } from './types-8d5f4ae0.js';
+import { SiblingOperations } from './siblings.js';
+import { GraphQLESLintRuleContext } from './types.js';
 import { GraphQLESTreeNode } from './estree-converter/types.js';
 import '@graphql-tools/utils';
-import 'graphql-config';
 import 'json-schema-to-ts';
+import 'graphql-config';
 
 declare function requireSiblingsOperations(ruleId: string, context: GraphQLESLintRuleContext): SiblingOperations | never;
 declare function requireGraphQLSchemaFromContext(ruleId: string, context: GraphQLESLintRuleContext): GraphQLSchema | never;