@graphql-eslint/eslint-plugin 3.19.3 → 3.20.0-alpha-20230703155329-a20556f

package/esm/rules/relay-edge-types.js

@@ -1,189 +1,190 @@
-import { getDocumentNodeFromSchema } from '@graphql-tools/utils';
-import { isObjectType, isScalarType, Kind, visit, } from 'graphql';
-import { getTypeName, requireGraphQLSchemaFromContext } from '../utils.js';
-const RULE_ID = 'relay-edge-types';
-const MESSAGE_MUST_BE_OBJECT_TYPE = 'MESSAGE_MUST_BE_OBJECT_TYPE';
-const MESSAGE_MISSING_EDGE_SUFFIX = 'MESSAGE_MISSING_EDGE_SUFFIX';
-const MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = 'MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE';
-const MESSAGE_SHOULD_IMPLEMENTS_NODE = 'MESSAGE_SHOULD_IMPLEMENTS_NODE';
+import { getDocumentNodeFromSchema } from "@graphql-tools/utils";
+import {
+  isObjectType,
+  isScalarType,
+  Kind,
+  visit
+} from "graphql";
+import { getTypeName, requireGraphQLSchemaFromContext } from "../utils.js";
+const RULE_ID = "relay-edge-types";
+const MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE";
+const MESSAGE_MISSING_EDGE_SUFFIX = "MESSAGE_MISSING_EDGE_SUFFIX";
+const MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE = "MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE";
+const MESSAGE_SHOULD_IMPLEMENTS_NODE = "MESSAGE_SHOULD_IMPLEMENTS_NODE";
 let edgeTypesCache;
-function getEdgeTypes(schema) {
-    // We don't want cache edgeTypes on test environment
-    // Otherwise edgeTypes will be same for all tests
-    if (process.env.NODE_ENV !== 'test' && edgeTypesCache) {
-        return edgeTypesCache;
-    }
-    const edgeTypes = new Set();
-    const visitor = {
-        ObjectTypeDefinition(node) {
-            var _a;
-            const typeName = node.name.value;
-            const hasConnectionSuffix = typeName.endsWith('Connection');
-            if (!hasConnectionSuffix) {
-                return;
-            }
-            const edges = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.find(field => field.name.value === 'edges');
-            if (edges) {
-                const edgesTypeName = getTypeName(edges);
-                const edgesType = schema.getType(edgesTypeName);
-                if (isObjectType(edgesType)) {
-                    edgeTypes.add(edgesTypeName);
-                }
-            }
-        },
-    };
-    const astNode = getDocumentNodeFromSchema(schema); // Transforms the schema into ASTNode
-    visit(astNode, visitor);
-    edgeTypesCache = edgeTypes;
+function getEdgeTypes(schema2) {
+  if (process.env.NODE_ENV !== "test" && edgeTypesCache) {
     return edgeTypesCache;
+  }
+  const edgeTypes = /* @__PURE__ */ new Set();
+  const visitor = {
+    ObjectTypeDefinition(node) {
+      const typeName = node.name.value;
+      const hasConnectionSuffix = typeName.endsWith("Connection");
+      if (!hasConnectionSuffix) {
+        return;
+      }
+      const edges = node.fields?.find((field) => field.name.value === "edges");
+      if (edges) {
+        const edgesTypeName = getTypeName(edges);
+        const edgesType = schema2.getType(edgesTypeName);
+        if (isObjectType(edgesType)) {
+          edgeTypes.add(edgesTypeName);
+        }
+      }
+    }
+  };
+  const astNode = getDocumentNodeFromSchema(schema2);
+  visit(astNode, visitor);
+  edgeTypesCache = edgeTypes;
+  return edgeTypesCache;
 }
 const schema = {
-    type: 'array',
-    maxItems: 1,
-    items: {
-        type: 'object',
-        additionalProperties: false,
-        minProperties: 1,
-        properties: {
-            withEdgeSuffix: {
-                type: 'boolean',
-                default: true,
-                description: 'Edge type name must end in "Edge".',
-            },
-            shouldImplementNode: {
-                type: 'boolean',
-                default: true,
-                description: "Edge type's field `node` must implement `Node` interface.",
-            },
-            listTypeCanWrapOnlyEdgeType: {
-                type: 'boolean',
-                default: true,
-                description: 'A list type should only wrap an edge type.',
-            },
-        },
-    },
+  type: "array",
+  maxItems: 1,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    minProperties: 1,
+    properties: {
+      withEdgeSuffix: {
+        type: "boolean",
+        default: true,
+        description: 'Edge type name must end in "Edge".'
+      },
+      shouldImplementNode: {
+        type: "boolean",
+        default: true,
+        description: "Edge type's field `node` must implement `Node` interface."
+      },
+      listTypeCanWrapOnlyEdgeType: {
+        type: "boolean",
+        default: true,
+        description: "A list type should only wrap an edge type."
+      }
+    }
+  }
 };
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            category: 'Schema',
-            description: [
-                'Set of rules to follow Relay specification for Edge types.',
-                '',
-                "- A type that is returned in list form by a connection type's `edges` field is considered by this spec to be an Edge type",
-                '- Edge type must be an Object type',
-                '- Edge type must contain a field `node` that return either Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types. Notably, this field cannot return a list',
-                '- Edge type must contain a field `cursor` that return either String, Scalar, or a non-null wrapper around one of those types',
-                '- Edge type name must end in "Edge" _(optional)_',
-                "- Edge type's field `node` must implement `Node` interface _(optional)_",
-                '- A list type should only wrap an edge type _(optional)_',
-            ].join('\n'),
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            isDisabledForAllConfig: true,
-            requiresSchema: true,
-            examples: [
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Schema",
+      description: [
+        "Set of rules to follow Relay specification for Edge types.",
+        "",
+        "- A type that is returned in list form by a connection type's `edges` field is considered by this spec to be an Edge type",
+        "- Edge type must be an Object type",
+        "- Edge type must contain a field `node` that return either Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types. Notably, this field cannot return a list",
+        "- Edge type must contain a field `cursor` that return either String, Scalar, or a non-null wrapper around one of those types",
+        '- Edge type name must end in "Edge" _(optional)_',
+        "- Edge type's field `node` must implement `Node` interface _(optional)_",
+        "- A list type should only wrap an edge type _(optional)_"
+      ].join("\n"),
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      isDisabledForAllConfig: true,
+      requiresSchema: true,
+      examples: [
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             type UserConnection {
               edges: [UserEdge]
               pageInfo: PageInfo!
             }
-          `,
-                },
-            ],
-        },
-        messages: {
-            [MESSAGE_MUST_BE_OBJECT_TYPE]: 'Edge type must be an Object type.',
-            [MESSAGE_MISSING_EDGE_SUFFIX]: 'Edge type must have "Edge" suffix.',
-            [MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE]: 'A list type should only wrap an edge type.',
-            [MESSAGE_SHOULD_IMPLEMENTS_NODE]: "Edge type's field `node` must implement `Node` interface.",
-        },
-        schema,
-    },
-    create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
-        const edgeTypes = getEdgeTypes(schema);
-        const options = {
-            withEdgeSuffix: true,
-            shouldImplementNode: true,
-            listTypeCanWrapOnlyEdgeType: true,
-            ...context.options[0],
-        };
-        const isNamedOrNonNullNamed = (node) => node.kind === Kind.NAMED_TYPE ||
-            (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.NAMED_TYPE);
-        const checkNodeField = (node) => {
-            var _a, _b;
-            const nodeField = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.find(field => field.name.value === 'node');
-            const message = 'return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.';
-            if (!nodeField) {
-                context.report({
-                    node: node.name,
-                    message: `Edge type must contain a field \`node\` that ${message}`,
-                });
-            }
-            else if (!isNamedOrNonNullNamed(nodeField.gqlType)) {
-                context.report({ node: nodeField.name, message: `Field \`node\` must ${message}` });
-            }
-            else if (options.shouldImplementNode) {
-                const nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode());
-                const type = schema.getType(nodeReturnTypeName);
-                if (!isObjectType(type)) {
-                    return;
-                }
-                const implementsNode = (_b = type.astNode.interfaces) === null || _b === void 0 ? void 0 : _b.some(n => n.name.value === 'Node');
-                if (!implementsNode) {
-                    context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
-                }
-            }
-        };
-        const checkCursorField = (node) => {
-            var _a;
-            const cursorField = (_a = node.fields) === null || _a === void 0 ? void 0 : _a.find(field => field.name.value === 'cursor');
-            const message = 'return either a String, Scalar, or a non-null wrapper wrapper around one of those types.';
-            if (!cursorField) {
-                context.report({
-                    node: node.name,
-                    message: `Edge type must contain a field \`cursor\` that ${message}`,
-                });
-                return;
-            }
-            const typeName = getTypeName(cursorField.rawNode());
-            if (!isNamedOrNonNullNamed(cursorField.gqlType) ||
-                (typeName !== 'String' && !isScalarType(schema.getType(typeName)))) {
-                context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
-            }
-        };
-        const listeners = {
-            ':matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType Name'(node) {
-                const type = schema.getType(node.value);
-                if (!isObjectType(type)) {
-                    context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
-                }
-            },
-            ':matches(ObjectTypeDefinition, ObjectTypeExtension)'(node) {
-                const typeName = node.name.value;
-                if (edgeTypes.has(typeName)) {
-                    checkNodeField(node);
-                    checkCursorField(node);
-                    if (options.withEdgeSuffix && !typeName.endsWith('Edge')) {
-                        context.report({ node: node.name, messageId: MESSAGE_MISSING_EDGE_SUFFIX });
-                    }
-                }
-            },
-        };
-        if (options.listTypeCanWrapOnlyEdgeType) {
-            listeners['FieldDefinition > .gqlType'] = (node) => {
-                if (node.kind === Kind.LIST_TYPE ||
-                    (node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.LIST_TYPE)) {
-                    const typeName = getTypeName(node.rawNode());
-                    if (!edgeTypes.has(typeName)) {
-                        context.report({ node, messageId: MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE });
-                    }
-                }
-            };
+          `
+          )
         }
-        return listeners;
+      ]
+    },
+    messages: {
+      [MESSAGE_MUST_BE_OBJECT_TYPE]: "Edge type must be an Object type.",
+      [MESSAGE_MISSING_EDGE_SUFFIX]: 'Edge type must have "Edge" suffix.',
+      [MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE]: "A list type should only wrap an edge type.",
+      [MESSAGE_SHOULD_IMPLEMENTS_NODE]: "Edge type's field `node` must implement `Node` interface."
     },
+    schema
+  },
+  create(context) {
+    const schema2 = requireGraphQLSchemaFromContext(RULE_ID, context);
+    const edgeTypes = getEdgeTypes(schema2);
+    const options = {
+      withEdgeSuffix: true,
+      shouldImplementNode: true,
+      listTypeCanWrapOnlyEdgeType: true,
+      ...context.options[0]
+    };
+    const isNamedOrNonNullNamed = (node) => node.kind === Kind.NAMED_TYPE || node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.NAMED_TYPE;
+    const checkNodeField = (node) => {
+      const nodeField = node.fields?.find((field) => field.name.value === "node");
+      const message = "return either a Scalar, Enum, Object, Interface, Union, or a non-null wrapper around one of those types.";
+      if (!nodeField) {
+        context.report({
+          node: node.name,
+          message: `Edge type must contain a field \`node\` that ${message}`
+        });
+      } else if (!isNamedOrNonNullNamed(nodeField.gqlType)) {
+        context.report({ node: nodeField.name, message: `Field \`node\` must ${message}` });
+      } else if (options.shouldImplementNode) {
+        const nodeReturnTypeName = getTypeName(nodeField.gqlType.rawNode());
+        const type = schema2.getType(nodeReturnTypeName);
+        if (!isObjectType(type)) {
+          return;
+        }
+        const implementsNode = type.astNode.interfaces?.some((n) => n.name.value === "Node");
+        if (!implementsNode) {
+          context.report({ node: node.name, messageId: MESSAGE_SHOULD_IMPLEMENTS_NODE });
+        }
+      }
+    };
+    const checkCursorField = (node) => {
+      const cursorField = node.fields?.find((field) => field.name.value === "cursor");
+      const message = "return either a String, Scalar, or a non-null wrapper wrapper around one of those types.";
+      if (!cursorField) {
+        context.report({
+          node: node.name,
+          message: `Edge type must contain a field \`cursor\` that ${message}`
+        });
+        return;
+      }
+      const typeName = getTypeName(cursorField.rawNode());
+      if (!isNamedOrNonNullNamed(cursorField.gqlType) || typeName !== "String" && !isScalarType(schema2.getType(typeName))) {
+        context.report({ node: cursorField.name, message: `Field \`cursor\` must ${message}` });
+      }
+    };
+    const listeners = {
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)[name.value=/Connection$/] > FieldDefinition[name.value=edges] > .gqlType Name"(node) {
+        const type = schema2.getType(node.value);
+        if (!isObjectType(type)) {
+          context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
+        }
+      },
+      ":matches(ObjectTypeDefinition, ObjectTypeExtension)"(node) {
+        const typeName = node.name.value;
+        if (edgeTypes.has(typeName)) {
+          checkNodeField(node);
+          checkCursorField(node);
+          if (options.withEdgeSuffix && !typeName.endsWith("Edge")) {
+            context.report({ node: node.name, messageId: MESSAGE_MISSING_EDGE_SUFFIX });
+          }
+        }
+      }
+    };
+    if (options.listTypeCanWrapOnlyEdgeType) {
+      listeners["FieldDefinition > .gqlType"] = (node) => {
+        if (node.kind === Kind.LIST_TYPE || node.kind === Kind.NON_NULL_TYPE && node.gqlType.kind === Kind.LIST_TYPE) {
+          const typeName = getTypeName(node.rawNode());
+          if (!edgeTypes.has(typeName)) {
+            context.report({ node, messageId: MESSAGE_LIST_TYPE_ONLY_EDGE_TYPE });
+          }
+        }
+      };
+    }
+    return listeners;
+  }
+};
+export {
+  rule
 };

package/esm/rules/relay-page-info.d.mts

@@ -0,0 +1,12 @@
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import 'json-schema-to-ts';
+import '../estree-converter/types.mjs';
+
+declare const rule: GraphQLESLintRule;
+
+export { rule };

package/esm/rules/relay-page-info.js

@@ -1,98 +1,96 @@
-import { isScalarType, Kind } from 'graphql';
-import { REPORT_ON_FIRST_CHARACTER, requireGraphQLSchemaFromContext } from '../utils.js';
-import { NON_OBJECT_TYPES } from './relay-connection-types.js';
-const RULE_ID = 'relay-page-info';
-const MESSAGE_MUST_EXIST = 'MESSAGE_MUST_EXIST';
-const MESSAGE_MUST_BE_OBJECT_TYPE = 'MESSAGE_MUST_BE_OBJECT_TYPE';
+import { isScalarType, Kind } from "graphql";
+import { REPORT_ON_FIRST_CHARACTER, requireGraphQLSchemaFromContext } from "../utils.js";
+import { NON_OBJECT_TYPES } from "./relay-connection-types.js";
+const RULE_ID = "relay-page-info";
+const MESSAGE_MUST_EXIST = "MESSAGE_MUST_EXIST";
+const MESSAGE_MUST_BE_OBJECT_TYPE = "MESSAGE_MUST_BE_OBJECT_TYPE";
 const notPageInfoTypesSelector = `:matches(${NON_OBJECT_TYPES})[name.value=PageInfo] > .name`;
 let hasPageInfoChecked = false;
-export const rule = {
-    meta: {
-        type: 'problem',
-        docs: {
-            category: 'Schema',
-            description: [
-                'Set of rules to follow Relay specification for `PageInfo` object.',
-                '',
-                '- `PageInfo` must be an Object type',
-                '- `PageInfo` must contain fields `hasPreviousPage` and `hasNextPage`, that return non-null Boolean',
-                '- `PageInfo` must contain fields `startCursor` and `endCursor`, that return either String or Scalar, which can be null if there are no results',
-            ].join('\n'),
-            url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
-            examples: [
-                {
-                    title: 'Correct',
-                    code: /* GraphQL */ `
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      category: "Schema",
+      description: [
+        "Set of rules to follow Relay specification for `PageInfo` object.",
+        "",
+        "- `PageInfo` must be an Object type",
+        "- `PageInfo` must contain fields `hasPreviousPage` and `hasNextPage`, that return non-null Boolean",
+        "- `PageInfo` must contain fields `startCursor` and `endCursor`, that return either String or Scalar, which can be null if there are no results"
+      ].join("\n"),
+      url: `https://the-guild.dev/graphql/eslint/rules/${RULE_ID}`,
+      examples: [
+        {
+          title: "Correct",
+          code: (
+            /* GraphQL */
+            `
             type PageInfo {
               hasPreviousPage: Boolean!
               hasNextPage: Boolean!
               startCursor: String
               endCursor: String
             }
-          `,
-                },
-            ],
-            isDisabledForAllConfig: true,
-            requiresSchema: true,
-        },
-        messages: {
-            [MESSAGE_MUST_EXIST]: 'The server must provide a `PageInfo` object.',
-            [MESSAGE_MUST_BE_OBJECT_TYPE]: '`PageInfo` must be an Object type.',
-        },
-        schema: [],
+          `
+          )
+        }
+      ],
+      isDisabledForAllConfig: true,
+      requiresSchema: true
+    },
+    messages: {
+      [MESSAGE_MUST_EXIST]: "The server must provide a `PageInfo` object.",
+      [MESSAGE_MUST_BE_OBJECT_TYPE]: "`PageInfo` must be an Object type."
     },
-    create(context) {
-        const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
-        if (process.env.NODE_ENV === 'test' || !hasPageInfoChecked) {
-            const pageInfoType = schema.getType('PageInfo');
-            if (!pageInfoType) {
-                context.report({
-                    loc: REPORT_ON_FIRST_CHARACTER,
-                    messageId: MESSAGE_MUST_EXIST,
-                });
+    schema: []
+  },
+  create(context) {
+    const schema = requireGraphQLSchemaFromContext(RULE_ID, context);
+    if (process.env.NODE_ENV === "test" || !hasPageInfoChecked) {
+      const pageInfoType = schema.getType("PageInfo");
+      if (!pageInfoType) {
+        context.report({
+          loc: REPORT_ON_FIRST_CHARACTER,
+          messageId: MESSAGE_MUST_EXIST
+        });
+      }
+      hasPageInfoChecked = true;
+    }
+    return {
+      [notPageInfoTypesSelector](node) {
+        context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
+      },
+      "ObjectTypeDefinition[name.value=PageInfo]"(node) {
+        const fieldMap = Object.fromEntries(
+          node.fields?.map((field) => [field.name.value, field]) || []
+        );
+        const checkField = (fieldName, typeName) => {
+          const field = fieldMap[fieldName];
+          let isAllowedType = false;
+          if (field) {
+            const type = field.gqlType;
+            if (typeName === "Boolean") {
+              isAllowedType = type.kind === Kind.NON_NULL_TYPE && type.gqlType.kind === Kind.NAMED_TYPE && type.gqlType.name.value === "Boolean";
+            } else if (type.kind === Kind.NAMED_TYPE) {
+              isAllowedType = type.name.value === "String" || isScalarType(schema.getType(type.name.value));
             }
-            hasPageInfoChecked = true;
-        }
-        return {
-            [notPageInfoTypesSelector](node) {
-                context.report({ node, messageId: MESSAGE_MUST_BE_OBJECT_TYPE });
-            },
-            'ObjectTypeDefinition[name.value=PageInfo]'(node) {
-                var _a;
-                const fieldMap = Object.fromEntries(((_a = node.fields) === null || _a === void 0 ? void 0 : _a.map(field => [field.name.value, field])) || []);
-                const checkField = (fieldName, typeName) => {
-                    const field = fieldMap[fieldName];
-                    let isAllowedType = false;
-                    if (field) {
-                        const type = field.gqlType;
-                        if (typeName === 'Boolean') {
-                            isAllowedType =
-                                type.kind === Kind.NON_NULL_TYPE &&
-                                    type.gqlType.kind === Kind.NAMED_TYPE &&
-                                    type.gqlType.name.value === 'Boolean';
-                        }
-                        else if (type.kind === Kind.NAMED_TYPE) {
-                            isAllowedType =
-                                type.name.value === 'String' || isScalarType(schema.getType(type.name.value));
-                        }
-                    }
-                    if (!isAllowedType) {
-                        const returnType = typeName === 'Boolean'
-                            ? 'non-null Boolean'
-                            : 'either String or Scalar, which can be null if there are no results';
-                        context.report({
-                            node: field ? field.name : node.name,
-                            message: field
-                                ? `Field \`${fieldName}\` must return ${returnType}.`
-                                : `\`PageInfo\` must contain a field \`${fieldName}\`, that return ${returnType}.`,
-                        });
-                    }
-                };
-                checkField('hasPreviousPage', 'Boolean');
-                checkField('hasNextPage', 'Boolean');
-                checkField('startCursor', 'String');
-                checkField('endCursor', 'String');
-            },
+          }
+          if (!isAllowedType) {
+            const returnType = typeName === "Boolean" ? "non-null Boolean" : "either String or Scalar, which can be null if there are no results";
+            context.report({
+              node: field ? field.name : node.name,
+              message: field ? `Field \`${fieldName}\` must return ${returnType}.` : `\`PageInfo\` must contain a field \`${fieldName}\`, that return ${returnType}.`
+            });
+          }
         };
-    },
+        checkField("hasPreviousPage", "Boolean");
+        checkField("hasNextPage", "Boolean");
+        checkField("startCursor", "String");
+        checkField("endCursor", "String");
+      }
+    };
+  }
+};
+export {
+  rule
 };

package/{typings/rules/require-deprecation-date.d.cts → esm/rules/require-deprecation-date.d.mts}

@@ -1,5 +1,12 @@
 import { FromSchema } from 'json-schema-to-ts';
-import { GraphQLESLintRule } from '../types.cjs';
+import { i as GraphQLESLintRule } from '../types-2e1afd7c.js';
+import '@graphql-tools/utils';
+import 'eslint';
+import 'estree';
+import 'graphql';
+import 'graphql-config';
+import '../estree-converter/types.mjs';
+
 declare const schema: {
     readonly type: "array";
     readonly maxItems: 1;
@@ -13,6 +20,7 @@ declare const schema: {
         };
     };
 };
-export type RuleOptions = FromSchema<typeof schema>;
-export declare const rule: GraphQLESLintRule<RuleOptions>;
-export {};
+type RuleOptions = FromSchema<typeof schema>;
+declare const rule: GraphQLESLintRule<RuleOptions>;
+
+export { RuleOptions, rule };