@graphql-eslint/eslint-plugin 3.14.0-alpha-20221221142641-4e1a924 → 3.14.0-alpha-20221222012949-5caade4

package/typings/configs/operations-recommended.d.ts

@@ -0,0 +1,50 @@
+declare const _default: {
+    extends: string;
+    rules: {
+        '@graphql-eslint/executable-definitions': string;
+        '@graphql-eslint/fields-on-correct-type': string;
+        '@graphql-eslint/fragments-on-composite-type': string;
+        '@graphql-eslint/known-argument-names': string;
+        '@graphql-eslint/known-directives': string;
+        '@graphql-eslint/known-fragment-names': string;
+        '@graphql-eslint/known-type-names': string;
+        '@graphql-eslint/lone-anonymous-operation': string;
+        '@graphql-eslint/naming-convention': (string | {
+            VariableDefinition: string;
+            OperationDefinition: {
+                style: string;
+                forbiddenPrefixes: string[];
+                forbiddenSuffixes: string[];
+            };
+            FragmentDefinition: {
+                style: string;
+                forbiddenPrefixes: string[];
+                forbiddenSuffixes: string[];
+            };
+        })[];
+        '@graphql-eslint/no-anonymous-operations': string;
+        '@graphql-eslint/no-deprecated': string;
+        '@graphql-eslint/no-duplicate-fields': string;
+        '@graphql-eslint/no-fragment-cycles': string;
+        '@graphql-eslint/no-undefined-variables': string;
+        '@graphql-eslint/no-unused-fragments': string;
+        '@graphql-eslint/no-unused-variables': string;
+        '@graphql-eslint/one-field-subscriptions': string;
+        '@graphql-eslint/overlapping-fields-can-be-merged': string;
+        '@graphql-eslint/possible-fragment-spread': string;
+        '@graphql-eslint/provided-required-arguments': string;
+        '@graphql-eslint/require-id-when-available': string;
+        '@graphql-eslint/scalar-leafs': string;
+        '@graphql-eslint/selection-set-depth': (string | {
+            maxDepth: number;
+        })[];
+        '@graphql-eslint/unique-argument-names': string;
+        '@graphql-eslint/unique-directive-names-per-location': string;
+        '@graphql-eslint/unique-input-field-names': string;
+        '@graphql-eslint/unique-variable-names': string;
+        '@graphql-eslint/value-literals-of-correct-type': string;
+        '@graphql-eslint/variables-are-input-types': string;
+        '@graphql-eslint/variables-in-allowed-position': string;
+    };
+};
+export default _default;

package/typings/configs/relay.d.cts

@@ -0,0 +1,10 @@
+declare const _default: {
+    extends: 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 _default;

package/typings/configs/relay.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    extends: 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 _default;

package/typings/configs/schema-all.d.cts

@@ -0,0 +1,15 @@
+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;
+    };
+};
+export default _default;

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

@@ -0,0 +1,15 @@
+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;
+    };
+};
+export default _default;

package/typings/configs/schema-recommended.d.cts

@@ -0,0 +1,47 @@
+declare const _default: {
+    extends: 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 _default;

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

@@ -0,0 +1,47 @@
+declare const _default: {
+    extends: 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 _default;

package/typings/documents.d.ts

@@ -0,0 +1,21 @@
+import { FragmentDefinitionNode, OperationDefinitionNode, SelectionSetNode, OperationTypeNode } from 'graphql';
+import { GraphQLProjectConfig } from 'graphql-config';
+export type FragmentSource = {
+    filePath: string;
+    document: FragmentDefinitionNode;
+};
+export type OperationSource = {
+    filePath: string;
+    document: OperationDefinitionNode;
+};
+export type SiblingOperations = {
+    available: boolean;
+    getFragment(fragmentName: string): FragmentSource[];
+    getFragments(): FragmentSource[];
+    getFragmentByType(typeName: string): FragmentSource[];
+    getFragmentsInUse(baseOperation: OperationDefinitionNode | FragmentDefinitionNode | SelectionSetNode, recursive?: boolean): FragmentDefinitionNode[];
+    getOperation(operationName: string): OperationSource[];
+    getOperations(): OperationSource[];
+    getOperationByType(operationType: OperationTypeNode): OperationSource[];
+};
+export declare function getDocuments(project: GraphQLProjectConfig): SiblingOperations;

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

@@ -0,0 +1,3 @@
+import { DocumentNode, GraphQLSchema } from 'graphql';
+import type { GraphQLESTreeNode } from './types';
+export declare function convertToESTree<T extends DocumentNode>(node: T, schema?: GraphQLSchema): GraphQLESTreeNode<T, false>;

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

@@ -0,0 +1,3 @@
+export * from './converter';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,40 @@
+import type { ASTNode, TypeInfo, TypeNode, DocumentNode, ExecutableDefinitionNode, NameNode, TypeDefinitionNode, FieldDefinitionNode, ObjectTypeExtensionNode, ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode, InterfaceTypeExtensionNode, SelectionSetNode, SelectionNode, DefinitionNode, TypeExtensionNode, DirectiveDefinitionNode, VariableNode, FieldNode, FragmentSpreadNode, EnumValueDefinitionNode, ArgumentNode, NamedTypeNode, EnumTypeDefinitionNode, EnumTypeExtensionNode, InputValueDefinitionNode, InputObjectTypeDefinitionNode, InputObjectTypeExtensionNode, InlineFragmentNode, VariableDefinitionNode, ListTypeNode, NonNullTypeNode, OperationTypeDefinitionNode } from 'graphql';
+import type { SourceLocation, Comment } from 'estree';
+import type { AST } from 'eslint';
+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];
+};
+export 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 = TypeDefinitionNode | TypeExtensionNode | ExecutableDefinitionNode | DirectiveDefinitionNode | FieldDefinitionNode | EnumValueDefinitionNode | FieldNode | FragmentSpreadNode | VariableNode | ArgumentNode | NamedTypeNode;
+type NodeWithType = FieldDefinitionNode | InputValueDefinitionNode | OperationTypeDefinitionNode | NonNullTypeNode | ListTypeNode | VariableDefinitionNode;
+type ParentNode<T> = T extends DocumentNode ? AST.Program : T extends DefinitionNode ? DocumentNode : T extends EnumValueDefinitionNode ? EnumTypeDefinitionNode | EnumTypeExtensionNode : T extends InputValueDefinitionNode ? InputObjectTypeDefinitionNode | InputObjectTypeExtensionNode | FieldDefinitionNode | DirectiveDefinitionNode : T extends FieldDefinitionNode ? ObjectTypeDefinitionNode | ObjectTypeExtensionNode | InterfaceTypeDefinitionNode | InterfaceTypeExtensionNode : T extends SelectionSetNode ? ExecutableDefinitionNode | FieldNode | InlineFragmentNode : T extends SelectionNode ? SelectionSetNode : T extends TypeNode ? NodeWithType : T extends NameNode ? NodeWithName : 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: ParentNode<T>;
+};
+export type GraphQLESTreeNode<T, W extends boolean = false> = T extends ASTNode ? {
+    [K in keyof Node<T, W>]: Node<T, W>[K] extends ReadonlyArray<infer ArrayItem> ? GraphQLESTreeNode<ArrayItem, W>[] : GraphQLESTreeNode<Node<T, W>[K], W>;
+} : T extends AST.Program ? T & {
+    parent: null;
+} : T;
+export {};

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

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

package/typings/graphql-config.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLConfig } from 'graphql-config';
+import { ParserOptions } from './types';
+export declare function loadOnDiskGraphQLConfig(filePath: string): GraphQLConfig;
+export declare function loadGraphQLConfig(options: ParserOptions): GraphQLConfig;

package/typings/index.d.cts

@@ -0,0 +1,9 @@
+export { rules } from './rules';
+export { parseForESLint } from './parser';
+export * from './testkit';
+export * from './types';
+export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './utils';
+export declare const processors: {
+    graphql: import("eslint").Linter.Processor<string | import("./processor").Block>;
+};
+export { configs } from './configs';

package/{index.d.ts → typings/index.d.ts}

@@ -6,8 +6,4 @@ export { requireGraphQLSchemaFromContext, requireSiblingsOperations } from './ut
 export declare const processors: {
     graphql: import("eslint").Linter.Processor<string | import("./processor").Block>;
 };
-export declare const configs: {
-    [k: string]: {
-        extends: string;
-    };
-};
+export { configs } from './configs';

package/typings/parser.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLESLintParseResult, ParserOptions } from './types';
+export declare function parseForESLint(code: string, options: ParserOptions): GraphQLESLintParseResult;

package/typings/processor.d.ts

@@ -0,0 +1,6 @@
+import { Linter } from 'eslint';
+export type Block = Linter.ProcessorFile & {
+    lineOffset: number;
+    offset: number;
+};
+export declare const processor: Linter.Processor<Block | string>;

package/typings/rules/alphabetize.d.ts

@@ -0,0 +1,76 @@
+import { GraphQLESLintRule } from '../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 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;
+            };
+            readonly groups: {
+                readonly minItems: 2;
+                readonly description: "Custom order group. Example: `['id', '*', 'createdAt', 'updatedAt']` where `*` says for everything else.";
+                readonly type: "array";
+                readonly uniqueItems: true;
+                readonly items: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/description-style.d.ts

@@ -0,0 +1,20 @@
+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 additionalProperties: false;
+        readonly minProperties: 1;
+        readonly properties: {
+            readonly style: {
+                readonly enum: readonly ["block", "inline"];
+                readonly default: "block";
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/rules/graphql-js-validation.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLESLintRule } from '../types';
+export declare const GRAPHQL_JS_VALIDATIONS: Record<string, GraphQLESLintRule>;

package/typings/rules/index.d.ts

@@ -0,0 +1,104 @@
+export declare const rules: {
+    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"[];
+        groups?: string[];
+    }[], false>;
+    'description-style': import("..").GraphQLESLintRule<{
+        style?: "block" | "inline";
+    }[], false>;
+    'input-name': import("..").GraphQLESLintRule<{
+        checkInputType?: boolean;
+        caseSensitiveInputType?: boolean;
+        checkQueries?: boolean;
+        checkMutations?: boolean;
+    }[], 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;
+            prefix?: 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;
+            prefix?: 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;
+            prefix?: 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;
+            prefix?: 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<{
+        disallow: ("mutation" | "subscription")[];
+    }[], 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<{
+        includeBoth?: boolean;
+    }[], true>;
+    'relay-connection-types': import("..").GraphQLESLintRule<any[], false>;
+    'relay-edge-types': import("..").GraphQLESLintRule<{
+        withEdgeSuffix?: boolean;
+        shouldImplementNode?: boolean;
+        listTypeCanWrapOnlyEdgeType?: boolean;
+    }[], true>;
+    'relay-page-info': import("..").GraphQLESLintRule<any[], false>;
+    'require-deprecation-date': import("..").GraphQLESLintRule<{
+        argumentName?: string;
+    }[], false>;
+    'require-deprecation-reason': import("..").GraphQLESLintRule<any[], 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<{
+        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/typings/rules/input-name.d.ts

@@ -0,0 +1,35 @@
+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 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";
+            };
+        };
+    };
+};
+export type RuleOptions = FromSchema<typeof schema>;
+export declare const rule: GraphQLESLintRule<RuleOptions>;
+export {};

package/typings/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 {};