@graphql-eslint/eslint-plugin 3.14.0-alpha-20221220004017-f1f0904 → 3.14.0-alpha-20221220160018-ba4832c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-eslint/eslint-plugin",
-  "version": "3.14.0-alpha-20221220004017-f1f0904",
+  "version": "3.14.0-alpha-20221220160018-ba4832c",
   "description": "GraphQL plugin for ESLint",
   "sideEffects": false,
   "peerDependencies": {

package/rules/alphabetize.d.ts

@@ -1,16 +1,67 @@
 import { GraphQLESLintRule } from '../types';
-declare const fieldsEnum: ('ObjectTypeDefinition' | 'InterfaceTypeDefinition' | 'InputObjectTypeDefinition')[];
-declare const valuesEnum: ['EnumTypeDefinition'];
-declare const selectionsEnum: ('OperationDefinition' | 'FragmentDefinition')[];
-declare const variablesEnum: ['OperationDefinition'];
-declare const argumentsEnum: ('FieldDefinition' | 'Field' | 'DirectiveDefinition' | 'Directive')[];
-export type AlphabetizeConfig = {
-    fields?: typeof fieldsEnum;
-    values?: typeof valuesEnum;
-    selections?: typeof selectionsEnum;
-    variables?: typeof variablesEnum;
-    arguments?: typeof argumentsEnum;
-    definitions?: boolean;
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly fields: {
+                readonly items: {
+                    readonly enum: ("ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition")[];
+                };
+                readonly description: "Fields of `type`, `interface`, and `input`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly values: {
+                readonly items: {
+                    readonly enum: ["EnumTypeDefinition"];
+                };
+                readonly description: "Values of `enum`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly selections: {
+                readonly items: {
+                    readonly enum: ("OperationDefinition" | "FragmentDefinition")[];
+                };
+                readonly description: "Selections of `fragment` and operations `query`, `mutation` and `subscription`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly variables: {
+                readonly items: {
+                    readonly enum: ["OperationDefinition"];
+                };
+                readonly description: "Variables of operations `query`, `mutation` and `subscription`.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly arguments: {
+                readonly items: {
+                    readonly enum: ("Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition")[];
+                };
+                readonly description: "Arguments of fields and directives.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+            readonly definitions: {
+                readonly type: "boolean";
+                readonly description: "Definitions – `type`, `interface`, `enum`, `scalar`, `input`, `union` and `directive`.";
+                readonly default: false;
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[AlphabetizeConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/rules/description-style.d.ts

@@ -1,6 +1,20 @@
 import { GraphQLESLintRule } from '../types';
-type DescriptionStyleRuleConfig = {
-    style: 'inline' | 'block';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly style: {
+                readonly enum: readonly ["block", "inline"];
+                readonly default: "block";
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[DescriptionStyleRuleConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/rules/index.d.ts

@@ -1,41 +1,99 @@
 export declare const rules: {
-    alphabetize: import("..").GraphQLESLintRule<[import("./alphabetize").AlphabetizeConfig], false>;
-    'description-style': import("..").GraphQLESLintRule<[{
-        style: "block" | "inline";
-    }], false>;
-    'input-name': import("..").GraphQLESLintRule<[{
+    alphabetize: import("..").GraphQLESLintRule<{
+        definitions?: boolean;
+        selections?: import("json-schema-to-ts/lib/types/type-utils").Writable<"OperationDefinition" | "FragmentDefinition">[];
+        arguments?: import("json-schema-to-ts/lib/types/type-utils").Writable<"Field" | "Directive" | "FieldDefinition" | "DirectiveDefinition">[];
+        values?: "EnumTypeDefinition"[];
+        fields?: import("json-schema-to-ts/lib/types/type-utils").Writable<"ObjectTypeDefinition" | "InterfaceTypeDefinition" | "InputObjectTypeDefinition">[];
+        variables?: "OperationDefinition"[];
+    }[], false>;
+    'description-style': import("..").GraphQLESLintRule<{
+        style?: "block" | "inline";
+    }[], false>;
+    'input-name': import("..").GraphQLESLintRule<{
         checkInputType?: boolean;
         caseSensitiveInputType?: boolean;
         checkQueries?: boolean;
         checkMutations?: boolean;
-    }], false>;
-    'match-document-filename': import("..").GraphQLESLintRule<[import("./match-document-filename").MatchDocumentFilenameRuleConfig], false>;
-    'naming-convention': import("..").GraphQLESLintRule<[import("./naming-convention").NamingConventionRuleConfig], false>;
+    }[], false>;
+    'lone-executable-definition': import("..").GraphQLESLintRule<{
+        ignore?: ("fragment" | "query" | "mutation" | "subscription")[];
+    }[], false>;
+    'match-document-filename': import("..").GraphQLESLintRule<{
+        fragment?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle"> | {
+            style?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle">;
+            suffix?: string;
+        };
+        query?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle"> | {
+            style?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle">;
+            suffix?: string;
+        };
+        mutation?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle"> | {
+            style?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle">;
+            suffix?: string;
+        };
+        subscription?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle"> | {
+            style?: import("json-schema-to-ts/lib/types/type-utils").Writable<import("../utils").CaseStyle | "matchDocumentStyle">;
+            suffix?: string;
+        };
+        fileExtension?: ".gql" | ".graphql";
+    }[], false>;
+    'naming-convention': import("..").GraphQLESLintRule<{
+        [x: string]: unknown;
+        types?: import("json-schema-to-ts/lib/types/type-utils").Writable<"camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE"> | {
+            style?: import("json-schema-to-ts/lib/types/type-utils").Writable<"camelCase" | "PascalCase" | "snake_case" | "UPPER_CASE">;
+            suffix?: string;
+            prefix?: string;
+            forbiddenPrefixes?: string[];
+            forbiddenSuffixes?: string[];
+            ignorePattern?: string;
+        };
+        allowLeadingUnderscore?: boolean;
+        allowTrailingUnderscore?: boolean;
+    }[], false>;
     'no-anonymous-operations': import("..").GraphQLESLintRule<any[], false>;
     'no-case-insensitive-enum-values-duplicates': import("..").GraphQLESLintRule<any[], false>;
     'no-deprecated': import("..").GraphQLESLintRule<[], true>;
     'no-duplicate-fields': import("..").GraphQLESLintRule<any[], false>;
     'no-hashtag-description': import("..").GraphQLESLintRule<any[], false>;
-    'no-root-type': import("..").GraphQLESLintRule<[{
+    'no-root-type': import("..").GraphQLESLintRule<{
         disallow: ("mutation" | "subscription")[];
-    }], false>;
+    }[], false>;
     'no-scalar-result-type-on-mutation': import("..").GraphQLESLintRule<any[], false>;
     'no-typename-prefix': import("..").GraphQLESLintRule<any[], false>;
     'no-unreachable-types': import("..").GraphQLESLintRule<any[], false>;
     'no-unused-fields': import("..").GraphQLESLintRule<any[], false>;
-    'relay-arguments': import("..").GraphQLESLintRule<[import("./relay-arguments").RelayArgumentsConfig], true>;
+    'relay-arguments': import("..").GraphQLESLintRule<{
+        includeBoth?: boolean;
+    }[], true>;
     'relay-connection-types': import("..").GraphQLESLintRule<any[], false>;
-    'relay-edge-types': import("..").GraphQLESLintRule<[import("./relay-edge-types").EdgeTypesConfig], true>;
+    'relay-edge-types': import("..").GraphQLESLintRule<{
+        withEdgeSuffix?: boolean;
+        shouldImplementNode?: boolean;
+        listTypeCanWrapOnlyEdgeType?: boolean;
+    }[], true>;
     'relay-page-info': import("..").GraphQLESLintRule<any[], false>;
-    'require-deprecation-date': import("..").GraphQLESLintRule<[{
+    'require-deprecation-date': import("..").GraphQLESLintRule<{
         argumentName?: string;
-    }], false>;
+    }[], false>;
     'require-deprecation-reason': import("..").GraphQLESLintRule<any[], false>;
-    'require-description': import("..").GraphQLESLintRule<[import("./require-description").RequireDescriptionRuleConfig], false>;
+    'require-description': import("..").GraphQLESLintRule<import("./require-description").RuleOptions, false>;
     'require-field-of-type-query-in-mutation-result': import("..").GraphQLESLintRule<any[], false>;
-    'require-id-when-available': import("..").GraphQLESLintRule<[import("./require-id-when-available").RequireIdWhenAvailableRuleConfig], true>;
-    'selection-set-depth': import("..").GraphQLESLintRule<[import("./selection-set-depth").SelectionSetDepthRuleConfig], false>;
-    'strict-id-in-types': import("..").GraphQLESLintRule<[import("./strict-id-in-types").StrictIdInTypesRuleConfig], false>;
+    'require-id-when-available': import("..").GraphQLESLintRule<{
+        fieldName?: string | string[];
+    }[], true>;
+    'selection-set-depth': import("..").GraphQLESLintRule<{
+        ignore?: string[];
+        maxDepth: number;
+    }[], false>;
+    'strict-id-in-types': import("..").GraphQLESLintRule<{
+        acceptedIdNames?: string[];
+        acceptedIdTypes?: string[];
+        exceptions?: {
+            types?: string[];
+            suffixes?: string[];
+        };
+    }[], false>;
     'unique-fragment-name': import("..").GraphQLESLintRule<any[], false>;
     'unique-operation-name': import("..").GraphQLESLintRule<any[], false>;
 };

package/rules/input-name.d.ts

@@ -1,9 +1,35 @@
 import { GraphQLESLintRule } from '../types';
-type InputNameRuleConfig = {
-    checkInputType?: boolean;
-    caseSensitiveInputType?: boolean;
-    checkQueries?: boolean;
-    checkMutations?: boolean;
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly checkInputType: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "Check that the input type name follows the convention <mutationName>Input";
+            };
+            readonly caseSensitiveInputType: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Allow for case discrepancies in the input type name";
+            };
+            readonly checkQueries: {
+                readonly type: "boolean";
+                readonly default: false;
+                readonly description: "Apply the rule to Queries";
+            };
+            readonly checkMutations: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Apply the rule to Mutations";
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[InputNameRuleConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/rules/lone-executable-definition.d.ts

@@ -0,0 +1,26 @@
+import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly minProperties: 1;
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly ignore: {
+                readonly maxItems: 3;
+                readonly items: {
+                    readonly enum: readonly ["fragment", "query", "mutation", "subscription"];
+                };
+                readonly description: "Allow certain definitions to be placed alongside others.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

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

@@ -1,17 +1,69 @@
 import { CaseStyle as _CaseStyle } from '../utils';
 import { GraphQLESLintRule } from '../types';
+import { FromSchema } from 'json-schema-to-ts';
 type CaseStyle = _CaseStyle | 'matchDocumentStyle';
-declare const ACCEPTED_EXTENSIONS: ['.gql', '.graphql'];
-type PropertySchema = {
-    style?: CaseStyle;
-    suffix?: string;
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly enum: CaseStyle[];
+            readonly description: `One of: ${string}`;
+        };
+        readonly asObject: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly minProperties: 1;
+            readonly properties: {
+                readonly style: {
+                    readonly enum: CaseStyle[];
+                };
+                readonly suffix: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly fileExtension: {
+                readonly enum: readonly [".gql", ".graphql"];
+            };
+            readonly query: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly mutation: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly subscription: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+            readonly fragment: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+    };
 };
-export type MatchDocumentFilenameRuleConfig = {
-    fileExtension?: typeof ACCEPTED_EXTENSIONS[number];
-    query?: CaseStyle | PropertySchema;
-    mutation?: CaseStyle | PropertySchema;
-    subscription?: CaseStyle | PropertySchema;
-    fragment?: CaseStyle | PropertySchema;
-};
-declare const rule: GraphQLESLintRule<[MatchDocumentFilenameRuleConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/rules/naming-convention.d.ts

@@ -1,37 +1,83 @@
 import { GraphQLESLintRule } from '../types';
-declare const KindToDisplayName: {
-    ObjectTypeDefinition: string;
-    InterfaceTypeDefinition: string;
-    EnumTypeDefinition: string;
-    ScalarTypeDefinition: string;
-    InputObjectTypeDefinition: string;
-    UnionTypeDefinition: string;
-    FieldDefinition: string;
-    InputValueDefinition: string;
-    Argument: string;
-    DirectiveDefinition: string;
-    EnumValueDefinition: string;
-    OperationDefinition: string;
-    FragmentDefinition: string;
-    VariableDefinition: string;
-};
-type AllowedKind = keyof typeof KindToDisplayName;
+import { FromSchema } from 'json-schema-to-ts';
 type AllowedStyle = 'camelCase' | 'PascalCase' | 'snake_case' | 'UPPER_CASE';
-type PropertySchema = {
-    style?: AllowedStyle;
-    suffix?: string;
-    prefix?: string;
-    forbiddenPrefixes?: string[];
-    forbiddenSuffixes?: string[];
-    ignorePattern?: string;
-};
-type Options = AllowedStyle | PropertySchema;
-export type NamingConventionRuleConfig = {
-    allowLeadingUnderscore?: boolean;
-    allowTrailingUnderscore?: boolean;
-    types?: Options;
-} & {
-    [key in `${AllowedKind}${string}`]?: Options;
+declare const schema: {
+    readonly definitions: {
+        readonly asString: {
+            readonly enum: AllowedStyle[];
+            readonly description: `One of: ${string}`;
+        };
+        readonly asObject: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly style: {
+                    readonly enum: AllowedStyle[];
+                };
+                readonly prefix: {
+                    readonly type: "string";
+                };
+                readonly suffix: {
+                    readonly type: "string";
+                };
+                readonly forbiddenPrefixes: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly forbiddenSuffixes: {
+                    readonly type: "array";
+                    readonly uniqueItems: true;
+                    readonly minItems: 1;
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly ignorePattern: {
+                    readonly type: "string";
+                    readonly description: "Option to skip validation of some words, e.g. acronyms";
+                };
+            };
+        };
+    };
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly allowLeadingUnderscore: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly allowTrailingUnderscore: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly types: {
+                readonly description: `Includes:\n${string}`;
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+        readonly patternProperties: {
+            readonly [x: string]: {
+                readonly oneOf: readonly [{
+                    readonly $ref: "#/definitions/asString";
+                }, {
+                    readonly $ref: "#/definitions/asObject";
+                }];
+            };
+        };
+        readonly description: string;
+    };
 };
-declare const rule: GraphQLESLintRule<[NamingConventionRuleConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/rules/no-anonymous-operations.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/no-case-insensitive-enum-values-duplicates.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/no-deprecated.d.ts

@@ -1,3 +1,2 @@
 import type { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule<[], true>;
-export default rule;
+export declare const rule: GraphQLESLintRule<[], true>;

package/rules/no-duplicate-fields.d.ts

@@ -1,3 +1,2 @@
 import type { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/no-hashtag-description.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

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

@@ -1,7 +1,25 @@
 import type { GraphQLESLintRule } from '../types';
-declare const ROOT_TYPES: ('mutation' | 'subscription')[];
-type NoRootTypeConfig = {
-    disallow: typeof ROOT_TYPES;
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly minItems: 1;
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["disallow"];
+        readonly properties: {
+            readonly disallow: {
+                readonly items: {
+                    readonly enum: readonly ["mutation", "subscription"];
+                };
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly minItems: 1;
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[NoRootTypeConfig]>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/rules/no-scalar-result-type-on-mutation.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/no-typename-prefix.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/no-unreachable-types.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/no-unused-fields.d.ts

@@ -1,3 +1,2 @@
 import { GraphQLESLintRule } from '../types';
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;

package/rules/relay-arguments.d.ts

@@ -1,6 +1,21 @@
 import { GraphQLESLintRule } from '../types';
-export type RelayArgumentsConfig = {
-    includeBoth?: boolean;
+import { FromSchema } from 'json-schema-to-ts';
+declare const schema: {
+    readonly type: "array";
+    readonly maxItems: 1;
+    readonly items: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly includeBoth: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Enforce including both forward and backward pagination arguments";
+            };
+        };
+    };
 };
-declare const rule: GraphQLESLintRule<[RelayArgumentsConfig], true>;
-export default rule;
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions, true>;
+export {};

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

@@ -1,5 +1,4 @@
 import { Kind } from 'graphql';
 import type { GraphQLESLintRule } from '../types';
 export declare const NON_OBJECT_TYPES: Kind[];
-declare const rule: GraphQLESLintRule;
-export default rule;
+export declare const rule: GraphQLESLintRule;