@storm-software/eslint

import { DepConstraint } from '@nx/eslint-plugin/src/utils/runtime-lint-utils'; import { StylisticCustomizeOptions } from '@stylistic/eslint-plugin'; import { ParserOptions } from '@typescript-eslint/parser'; import { Linter } from 'eslint'; import { FlatGitignoreOptions } from 'eslint-config-flat-gitignore'; /* eslint-disable */ /* prettier-ignore */ interface RuleOptions { /** * CSpell spellchecker */ '@cspell/spellchecker'?: Linter.RuleEntry<CspellSpellchecker> /** * Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more. * @see https://the-guild.dev/graphql/eslint/rules/alphabetize */ '@graphql-eslint/alphabetize'?: Linter.RuleEntry<GraphqlEslintAlphabetize> /** * Require all comments to follow the same style (either block or inline). * @see https://the-guild.dev/graphql/eslint/rules/description-style */ '@graphql-eslint/description-style'?: Linter.RuleEntry<GraphqlEslintDescriptionStyle> /** * A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/executable-definitions */ '@graphql-eslint/executable-definitions'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/fields-on-correct-type */ '@graphql-eslint/fields-on-correct-type'?: Linter.RuleEntry<[]> /** * Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition must also be a composite type. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/fragments-on-composite-type */ '@graphql-eslint/fragments-on-composite-type'?: Linter.RuleEntry<[]> /** * Require mutation argument to be always called "input" and input type to be called Mutation name + "Input". Using the same name for all input parameters will make your schemas easier to consume and more predictable. Using the same name as mutation for InputType will make it easier to find mutations that InputType belongs to. * @see https://the-guild.dev/graphql/eslint/rules/input-name */ '@graphql-eslint/input-name'?: Linter.RuleEntry<GraphqlEslintInputName> /** * A GraphQL field is only valid if all supplied arguments are defined by that field. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/known-argument-names */ '@graphql-eslint/known-argument-names'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all `@directive`s are known by the schema and legally positioned. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/known-directives */ '@graphql-eslint/known-directives'?: Linter.RuleEntry<GraphqlEslintKnownDirectives> /** * A GraphQL document is only valid if all `...Fragment` fragment spreads refer to fragments defined in the same document. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/known-fragment-names */ '@graphql-eslint/known-fragment-names'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if referenced types (specifically variable definitions and fragment conditions) are defined by the type schema. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/known-type-names */ '@graphql-eslint/known-type-names'?: Linter.RuleEntry<[]> /** * A GraphQL document that contains an anonymous operation (the `query` short-hand) is only valid if it contains only that one operation definition. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/lone-anonymous-operation */ '@graphql-eslint/lone-anonymous-operation'?: Linter.RuleEntry<[]> /** * Require queries, mutations, subscriptions or fragments to be located in separate files. * @see https://the-guild.dev/graphql/eslint/rules/lone-executable-definition */ '@graphql-eslint/lone-executable-definition'?: Linter.RuleEntry<GraphqlEslintLoneExecutableDefinition> /** * A GraphQL document is only valid if it contains only one schema definition. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/lone-schema-definition */ '@graphql-eslint/lone-schema-definition'?: Linter.RuleEntry<[]> /** * This rule allows you to enforce that the file name should match the operation name. * @see https://the-guild.dev/graphql/eslint/rules/match-document-filename */ '@graphql-eslint/match-document-filename'?: Linter.RuleEntry<GraphqlEslintMatchDocumentFilename> /** * Require names to follow specified conventions. * @see https://the-guild.dev/graphql/eslint/rules/naming-convention */ '@graphql-eslint/naming-convention'?: Linter.RuleEntry<GraphqlEslintNamingConvention> /** * Require name for your GraphQL operations. This is useful since most GraphQL client libraries are using the operation name for caching purposes. * @see https://the-guild.dev/graphql/eslint/rules/no-anonymous-operations */ '@graphql-eslint/no-anonymous-operations'?: Linter.RuleEntry<[]> /** * Enforce that deprecated fields or enum values are not in use by operations. * @see https://the-guild.dev/graphql/eslint/rules/no-deprecated */ '@graphql-eslint/no-deprecated'?: Linter.RuleEntry<[]> /** * Checks for duplicate fields in selection set, variables in operation definition, or in arguments set of a field. * @see https://the-guild.dev/graphql/eslint/rules/no-duplicate-fields */ '@graphql-eslint/no-duplicate-fields'?: Linter.RuleEntry<[]> /** * A GraphQL fragment is only valid when it does not have cycles in fragments usage. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/no-fragment-cycles */ '@graphql-eslint/no-fragment-cycles'?: Linter.RuleEntry<[]> /** * Requires to use `"""` or `"` for adding a GraphQL description instead of `#`. Allows to use hashtag for comments, as long as it's not attached to an AST definition. * @see https://the-guild.dev/graphql/eslint/rules/no-hashtag-description */ '@graphql-eslint/no-hashtag-description'?: Linter.RuleEntry<[]> /** * Disallow fragments that are used only in one place. * @see https://the-guild.dev/graphql/eslint/rules/no-one-place-fragments */ '@graphql-eslint/no-one-place-fragments'?: Linter.RuleEntry<[]> /** * Disallow using root types `mutation` and/or `subscription`. * @see https://the-guild.dev/graphql/eslint/rules/no-root-type */ '@graphql-eslint/no-root-type'?: Linter.RuleEntry<GraphqlEslintNoRootType> /** * Avoid scalar result type on mutation type to make sure to return a valid state. * @see https://the-guild.dev/graphql/eslint/rules/no-scalar-result-type-on-mutation */ '@graphql-eslint/no-scalar-result-type-on-mutation'?: Linter.RuleEntry<[]> /** * Enforces users to avoid using the type name in a field name while defining your schema. * @see https://the-guild.dev/graphql/eslint/rules/no-typename-prefix */ '@graphql-eslint/no-typename-prefix'?: Linter.RuleEntry<[]> /** * A GraphQL operation is only valid if all variables encountered, both directly and via fragment spreads, are defined by that operation. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/no-undefined-variables */ '@graphql-eslint/no-undefined-variables'?: Linter.RuleEntry<[]> /** * Requires all types to be reachable at some level by root level fields. * @see https://the-guild.dev/graphql/eslint/rules/no-unreachable-types */ '@graphql-eslint/no-unreachable-types'?: Linter.RuleEntry<[]> /** * Requires all fields to be used at some level by siblings operations. * @see https://the-guild.dev/graphql/eslint/rules/no-unused-fields */ '@graphql-eslint/no-unused-fields'?: Linter.RuleEntry<GraphqlEslintNoUnusedFields> /** * A GraphQL document is only valid if all fragment definitions are spread within operations, or spread within other fragments spread within operations. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/no-unused-fragments */ '@graphql-eslint/no-unused-fragments'?: Linter.RuleEntry<[]> /** * A GraphQL operation is only valid if all variables defined by an operation are used, either directly or within a spread fragment. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/no-unused-variables */ '@graphql-eslint/no-unused-variables'?: Linter.RuleEntry<[]> /** * A GraphQL subscription is valid only if it contains a single root field. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/one-field-subscriptions */ '@graphql-eslint/one-field-subscriptions'?: Linter.RuleEntry<[]> /** * A selection set is only valid if all fields (including spreading any fragments) either correspond to distinct response names or can be merged without ambiguity. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/overlapping-fields-can-be-merged */ '@graphql-eslint/overlapping-fields-can-be-merged'?: Linter.RuleEntry<[]> /** * A fragment spread is only valid if the type condition could ever possibly be true: if there is a non-empty intersection of the possible parent types, and possible types which pass the type condition. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/possible-fragment-spread */ '@graphql-eslint/possible-fragment-spread'?: Linter.RuleEntry<[]> /** * A type extension is only valid if the type is defined and has the same kind. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/possible-type-extension */ '@graphql-eslint/possible-type-extension'?: Linter.RuleEntry<[]> /** * A field or directive is only valid if all required (non-null without a default value) field arguments have been provided. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/provided-required-arguments */ '@graphql-eslint/provided-required-arguments'?: Linter.RuleEntry<[]> /** * Set of rules to follow Relay specification for Arguments. - A field that returns a Connection type must include forward pagination arguments (`first` and `after`), backward pagination arguments (`last` and `before`), or both Forward pagination arguments - `first` takes a non-negative integer - `after` takes the Cursor type Backward pagination arguments - `last` takes a non-negative integer - `before` takes the Cursor type * @see https://the-guild.dev/graphql/eslint/rules/relay-arguments */ '@graphql-eslint/relay-arguments'?: Linter.RuleEntry<GraphqlEslintRelayArguments> /** * Set of rules to follow Relay specification for Connection types. - Any type whose name ends in "Connection" is considered by spec to be a `Connection type` - Connection type must be an Object type - Connection type must contain a field `edges` that return a list type that wraps an edge type - Connection type must contain a field `pageInfo` that return a non-null `PageInfo` Object type * @see https://the-guild.dev/graphql/eslint/rules/relay-connection-types */ '@graphql-eslint/relay-connection-types'?: Linter.RuleEntry<[]> /** * 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)_ * @see https://the-guild.dev/graphql/eslint/rules/relay-edge-types */ '@graphql-eslint/relay-edge-types'?: Linter.RuleEntry<GraphqlEslintRelayEdgeTypes> /** * 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 * @see https://the-guild.dev/graphql/eslint/rules/relay-page-info */ '@graphql-eslint/relay-page-info'?: Linter.RuleEntry<[]> /** * Require deletion date on `@deprecated` directive. Suggest removing deprecated things after deprecated date. * @see https://the-guild.dev/graphql/eslint/rules/require-deprecation-date */ '@graphql-eslint/require-deprecation-date'?: Linter.RuleEntry<GraphqlEslintRequireDeprecationDate> /** * Require all deprecation directives to specify a reason. * @see https://the-guild.dev/graphql/eslint/rules/require-deprecation-reason */ '@graphql-eslint/require-deprecation-reason'?: Linter.RuleEntry<[]> /** * Enforce descriptions in type definitions and operations. * @see https://the-guild.dev/graphql/eslint/rules/require-description */ '@graphql-eslint/require-description'?: Linter.RuleEntry<GraphqlEslintRequireDescription> /** * Allow the client in one round-trip not only to call mutation but also to get a wagon of data to update their application. > Currently, no errors are reported for result type `union`, `interface` and `scalar`. * @see https://the-guild.dev/graphql/eslint/rules/require-field-of-type-query-in-mutation-result */ '@graphql-eslint/require-field-of-type-query-in-mutation-result'?: Linter.RuleEntry<[]> /** * Require fragments to be imported via an import expression. * @see https://the-guild.dev/graphql/eslint/rules/require-import-fragment */ '@graphql-eslint/require-import-fragment'?: Linter.RuleEntry<[]> /** * Require `input` or `type` fields to be non-nullable with `@oneOf` directive. * @see https://the-guild.dev/graphql/eslint/rules/require-nullable-fields-with-oneof */ '@graphql-eslint/require-nullable-fields-with-oneof'?: Linter.RuleEntry<[]> /** * Require nullable fields in root types. * @see https://the-guild.dev/graphql/eslint/rules/require-nullable-result-in-root */ '@graphql-eslint/require-nullable-result-in-root'?: Linter.RuleEntry<[]> /** * Enforce selecting specific fields when they are available on the GraphQL type. * @see https://the-guild.dev/graphql/eslint/rules/require-selections */ '@graphql-eslint/require-selections'?: Linter.RuleEntry<GraphqlEslintRequireSelections> /** * Enforce types with `@oneOf` directive have `error` and `ok` fields. * @see https://the-guild.dev/graphql/eslint/rules/require-type-pattern-with-oneof */ '@graphql-eslint/require-type-pattern-with-oneof'?: Linter.RuleEntry<[]> /** * A GraphQL document is valid only if all leaf fields (fields without sub selections) are of scalar or enum types. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/scalar-leafs */ '@graphql-eslint/scalar-leafs'?: Linter.RuleEntry<[]> /** * Limit the complexity of the GraphQL operations solely by their depth. Based on [graphql-depth-limit](https://npmjs.com/package/graphql-depth-limit). * @see https://the-guild.dev/graphql/eslint/rules/selection-set-depth */ '@graphql-eslint/selection-set-depth'?: Linter.RuleEntry<GraphqlEslintSelectionSetDepth> /** * Requires output types to have one unique identifier unless they do not have a logical one. Exceptions can be used to ignore output types that do not have unique identifiers. * @see https://the-guild.dev/graphql/eslint/rules/strict-id-in-types */ '@graphql-eslint/strict-id-in-types'?: Linter.RuleEntry<GraphqlEslintStrictIdInTypes> /** * A GraphQL field or directive is only valid if all supplied arguments are uniquely named. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-argument-names */ '@graphql-eslint/unique-argument-names'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all defined directives have unique names. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-directive-names */ '@graphql-eslint/unique-directive-names'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all non-repeatable directives at a given location are uniquely named. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-directive-names-per-location */ '@graphql-eslint/unique-directive-names-per-location'?: Linter.RuleEntry<[]> /** * A GraphQL enum type is only valid if all its values are uniquely named. > This rule disallows case-insensitive enum values duplicates too. * @see https://the-guild.dev/graphql/eslint/rules/unique-enum-value-names */ '@graphql-eslint/unique-enum-value-names'?: Linter.RuleEntry<[]> /** * A GraphQL complex type is only valid if all its fields are uniquely named. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-field-definition-names */ '@graphql-eslint/unique-field-definition-names'?: Linter.RuleEntry<[]> /** * Enforce unique fragment names across your project. * @see https://the-guild.dev/graphql/eslint/rules/unique-fragment-name */ '@graphql-eslint/unique-fragment-name'?: Linter.RuleEntry<[]> /** * A GraphQL input object value is only valid if all supplied fields are uniquely named. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-input-field-names */ '@graphql-eslint/unique-input-field-names'?: Linter.RuleEntry<[]> /** * Enforce unique operation names across your project. * @see https://the-guild.dev/graphql/eslint/rules/unique-operation-name */ '@graphql-eslint/unique-operation-name'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if it has only one type per operation. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-operation-types */ '@graphql-eslint/unique-operation-types'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all defined types have unique names. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-type-names */ '@graphql-eslint/unique-type-names'?: Linter.RuleEntry<[]> /** * A GraphQL operation is only valid if all its variables are uniquely named. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/unique-variable-names */ '@graphql-eslint/unique-variable-names'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all value literals are of the type expected at their position. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/value-literals-of-correct-type */ '@graphql-eslint/value-literals-of-correct-type'?: Linter.RuleEntry<[]> /** * A GraphQL operation is only valid if all the variables it defines are of input types (scalar, enum, or input object). > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/variables-are-input-types */ '@graphql-eslint/variables-are-input-types'?: Linter.RuleEntry<[]> /** * Variables passed to field arguments conform to type. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/variables-in-allowed-position */ '@graphql-eslint/variables-in-allowed-position'?: Linter.RuleEntry<[]> /** * Enforce font-display behavior with Google Fonts. * @see https://nextjs.org/docs/messages/google-font-display */ '@next/next/google-font-display'?: Linter.RuleEntry<[]> /** * Ensure `preconnect` is used with Google Fonts. * @see https://nextjs.org/docs/messages/google-font-preconnect */ '@next/next/google-font-preconnect'?: Linter.RuleEntry<[]> /** * Enforce `id` attribute on `next/script` components with inline content. * @see https://nextjs.org/docs/messages/inline-script-id */ '@next/next/inline-script-id'?: Linter.RuleEntry<[]> /** * Prefer `next/script` component when using the inline script for Google Analytics. * @see https://nextjs.org/docs/messages/next-script-for-ga */ '@next/next/next-script-for-ga'?: Linter.RuleEntry<[]> /** * Prevent assignment to the `module` variable. * @see https://nextjs.org/docs/messages/no-assign-module-variable */ '@next/next/no-assign-module-variable'?: Linter.RuleEntry<[]> /** * Prevent Client Components from being async functions. * @see https://nextjs.org/docs/messages/no-async-client-component */ '@next/next/no-async-client-component'?: Linter.RuleEntry<[]> /** * Prevent usage of `next/script`'s `beforeInteractive` strategy outside of `pages/_document.js`. * @see https://nextjs.org/docs/messages/no-before-interactive-script-outside-document */ '@next/next/no-before-interactive-script-outside-document'?: Linter.RuleEntry<[]> /** * Prevent manual stylesheet tags. * @see https://nextjs.org/docs/messages/no-css-tags */ '@next/next/no-css-tags'?: Linter.RuleEntry<[]> /** * Prevent importing `next/document` outside of `pages/_document.js`. * @see https://nextjs.org/docs/messages/no-document-import-in-page */ '@next/next/no-document-import-in-page'?: Linter.RuleEntry<[]> /** * Prevent duplicate usage of `<Head>` in `pages/_document.js`. * @see https://nextjs.org/docs/messages/no-duplicate-head */ '@next/next/no-duplicate-head'?: Linter.RuleEntry<[]> /** * Prevent usage of `<head>` element. * @see https://nextjs.org/docs/messages/no-head-element */ '@next/next/no-head-element'?: Linter.RuleEntry<[]> /** * Prevent usage of `next/head` in `pages/_document.js`. * @see https://nextjs.org/docs/messages/no-head-import-in-document */ '@next/next/no-head-import-in-document'?: Linter.RuleEntry<[]> /** * Prevent usage of `<a>` elements to navigate to internal Next.js pages. * @see https://nextjs.org/docs/messages/no-html-link-for-pages */ '@next/next/no-html-link-for-pages'?: Linter.RuleEntry<NextNextNoHtmlLinkForPages> /** * Prevent usage of `<img>` element due to slower LCP and higher bandwidth. * @see https://nextjs.org/docs/messages/no-img-element */ '@next/next/no-img-element'?: Linter.RuleEntry<[]> /** * Prevent page-only custom fonts. * @see https://nextjs.org/docs/messages/no-page-custom-font */ '@next/next/no-page-custom-font'?: Linter.RuleEntry<[]> /** * Prevent usage of `next/script` in `next/head` component. * @see https://nextjs.org/docs/messages/no-script-component-in-head */ '@next/next/no-script-component-in-head'?: Linter.RuleEntry<[]> /** * Prevent usage of `styled-jsx` in `pages/_document.js`. * @see https://nextjs.org/docs/messages/no-styled-jsx-in-document */ '@next/next/no-styled-jsx-in-document'?: Linter.RuleEntry<[]> /** * Prevent synchronous scripts. * @see https://nextjs.org/docs/messages/no-sync-scripts */ '@next/next/no-sync-scripts'?: Linter.RuleEntry<[]> /** * Prevent usage of `<title>` with `Head` component from `next/document`. * @see https://nextjs.org/docs/messages/no-title-in-document-head */ '@next/next/no-title-in-document-head'?: Linter.RuleEntry<[]> /** * Prevent common typos in Next.js data fetching functions. */ '@next/next/no-typos'?: Linter.RuleEntry<[]> /** * Prevent duplicate polyfills from Polyfill.io. * @see https://nextjs.org/docs/messages/no-unwanted-polyfillio */ '@next/next/no-unwanted-polyfillio'?: Linter.RuleEntry<[]> /** * Checks dependencies in project's package.json for version mismatches * @see https://github.com/nrwl/nx/blob/22.7.4/docs/generated/packages/eslint-plugin/documents/dependency-checks.md */ '@nx/dependency-checks'?: Linter.RuleEntry<NxDependencyChecks> /** * Ensure that module boundaries are respected within the monorepo * @see https://github.com/nrwl/nx/blob/22.7.4/docs/generated/packages/eslint-plugin/documents/enforce-module-boundaries.md */ '@nx/enforce-module-boundaries'?: Linter.RuleEntry<NxEnforceModuleBoundaries> /** * Checks common nx-plugin configuration files for validity */ '@nx/nx-plugin-checks'?: Linter.RuleEntry<NxNxPluginChecks> /** * Enforce getter and setter pairs in objects and classes * @see https://eslint.org/docs/latest/rules/accessor-pairs */ 'accessor-pairs'?: Linter.RuleEntry<AccessorPairs> /** * Enforce linebreaks after opening and before closing array brackets * @see https://eslint.org/docs/latest/rules/array-bracket-newline * @deprecated */ 'array-bracket-newline'?: Linter.RuleEntry<ArrayBracketNewline> /** * Enforce consistent spacing inside array brackets * @see https://eslint.org/docs/latest/rules/array-bracket-spacing * @deprecated */ 'array-bracket-spacing'?: Linter.RuleEntry<ArrayBracketSpacing> /** * Enforce `return` statements in callbacks of array methods * @see https://eslint.org/docs/latest/rules/array-callback-return */ 'array-callback-return'?: Linter.RuleEntry<ArrayCallbackReturn> /** * Enforce line breaks after each array element * @see https://eslint.org/docs/latest/rules/array-element-newline * @deprecated */ 'array-element-newline'?: Linter.RuleEntry<ArrayElementNewline> /** * Require braces around arrow function bodies * @see https://eslint.org/docs/latest/rules/arrow-body-style */ 'arrow-body-style'?: Linter.RuleEntry<ArrowBodyStyle> /** * Require parentheses around arrow function arguments * @see https://eslint.org/docs/latest/rules/arrow-parens * @deprecated */ 'arrow-parens'?: Linter.RuleEntry<ArrowParens> /** * Enforce consistent spacing before and after the arrow in arrow functions * @see https://eslint.org/docs/latest/rules/arrow-spacing * @deprecated */ 'arrow-spacing'?: Linter.RuleEntry<ArrowSpacing> /** * apply `jsx-a11y/alt-text` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/alt-text/ */ 'astro/jsx-a11y/alt-text'?: Linter.RuleEntry<AstroJsxA11YAltText> /** * apply `jsx-a11y/anchor-ambiguous-text` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-ambiguous-text/ */ 'astro/jsx-a11y/anchor-ambiguous-text'?: Linter.RuleEntry<AstroJsxA11YAnchorAmbiguousText> /** * apply `jsx-a11y/anchor-has-content` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-has-content/ */ 'astro/jsx-a11y/anchor-has-content'?: Linter.RuleEntry<AstroJsxA11YAnchorHasContent> /** * apply `jsx-a11y/anchor-is-valid` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-is-valid/ */ 'astro/jsx-a11y/anchor-is-valid'?: Linter.RuleEntry<AstroJsxA11YAnchorIsValid> /** * apply `jsx-a11y/aria-activedescendant-has-tabindex` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-activedescendant-has-tabindex/ */ 'astro/jsx-a11y/aria-activedescendant-has-tabindex'?: Linter.RuleEntry<AstroJsxA11YAriaActivedescendantHasTabindex> /** * apply `jsx-a11y/aria-props` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-props/ */ 'astro/jsx-a11y/aria-props'?: Linter.RuleEntry<AstroJsxA11YAriaProps> /** * apply `jsx-a11y/aria-proptypes` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-proptypes/ */ 'astro/jsx-a11y/aria-proptypes'?: Linter.RuleEntry<AstroJsxA11YAriaProptypes> /** * apply `jsx-a11y/aria-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-role/ */ 'astro/jsx-a11y/aria-role'?: Linter.RuleEntry<AstroJsxA11YAriaRole> /** * apply `jsx-a11y/aria-unsupported-elements` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-unsupported-elements/ */ 'astro/jsx-a11y/aria-unsupported-elements'?: Linter.RuleEntry<AstroJsxA11YAriaUnsupportedElements> /** * apply `jsx-a11y/autocomplete-valid` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/autocomplete-valid/ */ 'astro/jsx-a11y/autocomplete-valid'?: Linter.RuleEntry<AstroJsxA11YAutocompleteValid> /** * apply `jsx-a11y/click-events-have-key-events` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/click-events-have-key-events/ */ 'astro/jsx-a11y/click-events-have-key-events'?: Linter.RuleEntry<AstroJsxA11YClickEventsHaveKeyEvents> /** * apply `jsx-a11y/control-has-associated-label` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/control-has-associated-label/ */ 'astro/jsx-a11y/control-has-associated-label'?: Linter.RuleEntry<AstroJsxA11YControlHasAssociatedLabel> /** * apply `jsx-a11y/heading-has-content` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/heading-has-content/ */ 'astro/jsx-a11y/heading-has-content'?: Linter.RuleEntry<AstroJsxA11YHeadingHasContent> /** * apply `jsx-a11y/html-has-lang` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/html-has-lang/ */ 'astro/jsx-a11y/html-has-lang'?: Linter.RuleEntry<AstroJsxA11YHtmlHasLang> /** * apply `jsx-a11y/iframe-has-title` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/iframe-has-title/ */ 'astro/jsx-a11y/iframe-has-title'?: Linter.RuleEntry<AstroJsxA11YIframeHasTitle> /** * apply `jsx-a11y/img-redundant-alt` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/img-redundant-alt/ */ 'astro/jsx-a11y/img-redundant-alt'?: Linter.RuleEntry<AstroJsxA11YImgRedundantAlt> /** * apply `jsx-a11y/interactive-supports-focus` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/interactive-supports-focus/ */ 'astro/jsx-a11y/interactive-supports-focus'?: Linter.RuleEntry<AstroJsxA11YInteractiveSupportsFocus> /** * apply `jsx-a11y/label-has-associated-control` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/label-has-associated-control/ */ 'astro/jsx-a11y/label-has-associated-control'?: Linter.RuleEntry<AstroJsxA11YLabelHasAssociatedControl> /** * apply `jsx-a11y/lang` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/lang/ */ 'astro/jsx-a11y/lang'?: Linter.RuleEntry<AstroJsxA11YLang> /** * apply `jsx-a11y/media-has-caption` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/media-has-caption/ */ 'astro/jsx-a11y/media-has-caption'?: Linter.RuleEntry<AstroJsxA11YMediaHasCaption> /** * apply `jsx-a11y/mouse-events-have-key-events` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/mouse-events-have-key-events/ */ 'astro/jsx-a11y/mouse-events-have-key-events'?: Linter.RuleEntry<AstroJsxA11YMouseEventsHaveKeyEvents> /** * apply `jsx-a11y/no-access-key` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-access-key/ */ 'astro/jsx-a11y/no-access-key'?: Linter.RuleEntry<AstroJsxA11YNoAccessKey> /** * apply `jsx-a11y/no-aria-hidden-on-focusable` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-aria-hidden-on-focusable/ */ 'astro/jsx-a11y/no-aria-hidden-on-focusable'?: Linter.RuleEntry<AstroJsxA11YNoAriaHiddenOnFocusable> /** * apply `jsx-a11y/no-autofocus` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-autofocus/ */ 'astro/jsx-a11y/no-autofocus'?: Linter.RuleEntry<AstroJsxA11YNoAutofocus> /** * apply `jsx-a11y/no-distracting-elements` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-distracting-elements/ */ 'astro/jsx-a11y/no-distracting-elements'?: Linter.RuleEntry<AstroJsxA11YNoDistractingElements> /** * apply `jsx-a11y/no-interactive-element-to-noninteractive-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-interactive-element-to-noninteractive-role/ */ 'astro/jsx-a11y/no-interactive-element-to-noninteractive-role'?: Linter.RuleEntry<AstroJsxA11YNoInteractiveElementToNoninteractiveRole> /** * apply `jsx-a11y/no-noninteractive-element-interactions` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-element-interactions/ */ 'astro/jsx-a11y/no-noninteractive-element-interactions'?: Linter.RuleEntry<AstroJsxA11YNoNoninteractiveElementInteractions> /** * apply `jsx-a11y/no-noninteractive-element-to-interactive-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-element-to-interactive-role/ */ 'astro/jsx-a11y/no-noninteractive-element-to-interactive-role'?: Linter.RuleEntry<AstroJsxA11YNoNoninteractiveElementToInteractiveRole> /** * apply `jsx-a11y/no-noninteractive-tabindex` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-tabindex/ */ 'astro/jsx-a11y/no-noninteractive-tabindex'?: Linter.RuleEntry<AstroJsxA11YNoNoninteractiveTabindex> /** * apply `jsx-a11y/no-redundant-roles` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-redundant-roles/ */ 'astro/jsx-a11y/no-redundant-roles'?: Linter.RuleEntry<AstroJsxA11YNoRedundantRoles> /** * apply `jsx-a11y/no-static-element-interactions` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-static-element-interactions/ */ 'astro/jsx-a11y/no-static-element-interactions'?: Linter.RuleEntry<AstroJsxA11YNoStaticElementInteractions> /** * apply `jsx-a11y/prefer-tag-over-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/prefer-tag-over-role/ */ 'astro/jsx-a11y/prefer-tag-over-role'?: Linter.RuleEntry<AstroJsxA11YPreferTagOverRole> /** * apply `jsx-a11y/role-has-required-aria-props` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/role-has-required-aria-props/ */ 'astro/jsx-a11y/role-has-required-aria-props'?: Linter.RuleEntry<AstroJsxA11YRoleHasRequiredAriaProps> /** * apply `jsx-a11y/role-supports-aria-props` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/role-supports-aria-props/ */ 'astro/jsx-a11y/role-supports-aria-props'?: Linter.RuleEntry<AstroJsxA11YRoleSupportsAriaProps> /** * apply `jsx-a11y/scope` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/scope/ */ 'astro/jsx-a11y/scope'?: Linter.RuleEntry<AstroJsxA11YScope> /** * apply `jsx-a11y/tabindex-no-positive` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/tabindex-no-positive/ */ 'astro/jsx-a11y/tabindex-no-positive'?: Linter.RuleEntry<AstroJsxA11YTabindexNoPositive> /** * the client:only directive is missing the correct component's framework value * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/missing-client-only-directive-value/ */ 'astro/missing-client-only-directive-value'?: Linter.RuleEntry<[]> /** * disallow conflicting set directives and child contents * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-conflict-set-directives/ */ 'astro/no-conflict-set-directives'?: Linter.RuleEntry<[]> /** * disallow using deprecated `Astro.canonicalURL` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-canonicalurl/ */ 'astro/no-deprecated-astro-canonicalurl'?: Linter.RuleEntry<[]> /** * disallow using deprecated `Astro.fetchContent()` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-fetchcontent/ */ 'astro/no-deprecated-astro-fetchcontent'?: Linter.RuleEntry<[]> /** * disallow using deprecated `Astro.resolve()` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-resolve/ */ 'astro/no-deprecated-astro-resolve'?: Linter.RuleEntry<[]> /** * disallow using deprecated `getEntryBySlug()` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-getentrybyslug/ */ 'astro/no-deprecated-getentrybyslug'?: Linter.RuleEntry<[]> /** * disallow value export * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-exports-from-components/ */ 'astro/no-exports-from-components'?: Linter.RuleEntry<[]> /** * disallow `prerender` export outside of pages/ directory * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-prerender-export-outside-pages/ */ 'astro/no-prerender-export-outside-pages'?: Linter.RuleEntry<[]> /** * disallow use of `set:html` to prevent XSS attack * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-html-directive/ */ 'astro/no-set-html-directive'?: Linter.RuleEntry<[]> /** * disallow use of `set:text` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-text-directive/ */ 'astro/no-set-text-directive'?: Linter.RuleEntry<[]> /** * disallow inline `<script>` without `src` to encourage CSP-safe patterns * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-unsafe-inline-scripts/ */ 'astro/no-unsafe-inline-scripts'?: Linter.RuleEntry<AstroNoUnsafeInlineScripts> /** * disallow selectors defined in `style` tag that don't use in HTML * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-unused-css-selector/ */ 'astro/no-unused-css-selector'?: Linter.RuleEntry<[]> /** * disallow unused `define:vars={...}` in `style` tag * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-unused-define-vars-in-style/ */ 'astro/no-unused-define-vars-in-style'?: Linter.RuleEntry<[]> /** * require `class:list` directives instead of `class` with expressions * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/prefer-class-list-directive/ */ 'astro/prefer-class-list-directive'?: Linter.RuleEntry<[]> /** * require use object instead of ternary expression in `class:list` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/prefer-object-class-list/ */ 'astro/prefer-object-class-list'?: Linter.RuleEntry<[]> /** * require use split array elements in `class:list` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/prefer-split-class-list/ */ 'astro/prefer-split-class-list'?: Linter.RuleEntry<AstroPreferSplitClassList> /** * Require or disallow semicolons instead of ASI * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/semi/ */ 'astro/semi'?: Linter.RuleEntry<AstroSemi> /** * enforce sorting of attributes * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/sort-attributes/ */ 'astro/sort-attributes'?: Linter.RuleEntry<AstroSortAttributes> /** * disallow warnings when compiling. * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/valid-compile/ */ 'astro/valid-compile'?: Linter.RuleEntry<[]> /** * Ensures the file has a organization specific banner at the top of source code files * @see https://developer.stormsoftware.com/eslint/rules/banner */ 'banner/banner'?: Linter.RuleEntry<BannerBanner> /** * Enforce the use of variables within the scope they are defined * @see https://eslint.org/docs/latest/rules/block-scoped-var */ 'block-scoped-var'?: Linter.RuleEntry<[]> /** * Disallow or enforce spaces inside of blocks after opening block and before closing block * @see https://eslint.org/docs/latest/rules/block-spacing * @deprecated */ 'block-spacing'?: Linter.RuleEntry<BlockSpacing> /** * Enforce consistent brace style for blocks * @see https://eslint.org/docs/latest/rules/brace-style * @deprecated */ 'brace-style'?: Linter.RuleEntry<BraceStyle> /** * Require `return` statements after callbacks * @see https://eslint.org/docs/latest/rules/callback-return * @deprecated */ 'callback-return'?: Linter.RuleEntry<CallbackReturn> /** * Enforce camelcase naming convention * @see https://eslint.org/docs/latest/rules/camelcase */ 'camelcase'?: Linter.RuleEntry<Camelcase> /** * Enforce or disallow capitalization of the first letter of a comment * @see https://eslint.org/docs/latest/rules/capitalized-comments */ 'capitalized-comments'?: Linter.RuleEntry<CapitalizedComments> /** * Enforce that class methods utilize `this` * @see https://eslint.org/docs/latest/rules/class-methods-use-this */ 'class-methods-use-this'?: Linter.RuleEntry<ClassMethodsUseThis> /** * Require or disallow trailing commas * @see https://eslint.org/docs/latest/rules/comma-dangle * @deprecated */ 'comma-dangle'?: Linter.RuleEntry<CommaDangle> /** * Enforce consistent spacing before and after commas * @see https://eslint.org/docs/latest/rules/comma-spacing * @deprecated */ 'comma-spacing'?: Linter.RuleEntry<CommaSpacing> /** * Enforce consistent comma style * @see https://eslint.org/docs/latest/rules/comma-style * @deprecated */ 'comma-style'?: Linter.RuleEntry<CommaStyle> /** * Enforce a maximum cyclomatic complexity allowed in a program * @see https://eslint.org/docs/latest/rules/complexity */ 'complexity'?: Linter.RuleEntry<Complexity> /** * Enforce consistent spacing inside computed property brackets * @see https://eslint.org/docs/latest/rules/computed-property-spacing * @deprecated */ 'computed-property-spacing'?: Linter.RuleEntry<ComputedPropertySpacing> /** * Require `return` statements to either always or never specify values * @see https://eslint.org/docs/latest/rules/consistent-return */ 'consistent-return'?: Linter.RuleEntry<ConsistentReturn> /** * Enforce consistent naming when capturing the current execution context * @see https://eslint.org/docs/latest/rules/consistent-this */ 'consistent-this'?: Linter.RuleEntry<ConsistentThis> /** * Require `super()` calls in constructors * @see https://eslint.org/docs/latest/rules/constructor-super */ 'constructor-super'?: Linter.RuleEntry<[]> /** * Enforce consistent brace style for all control statements * @see https://eslint.org/docs/latest/rules/curly */ 'curly'?: Linter.RuleEntry<Curly> /** * Require `default` cases in `switch` statements * @see https://eslint.org/docs/latest/rules/default-case */ 'default-case'?: Linter.RuleEntry<DefaultCase> /** * Enforce `default` clauses in `switch` statements to be last * @see https://eslint.org/docs/latest/rules/default-case-last */ 'default-case-last'?: Linter.RuleEntry<[]> /** * Enforce default parameters to be last * @see https://eslint.org/docs/latest/rules/default-param-last */ 'default-param-last'?: Linter.RuleEntry<[]> /** * Enforce consistent newlines before and after dots * @see https://eslint.org/docs/latest/rules/dot-location * @deprecated */ 'dot-location'?: Linter.RuleEntry<DotLocation> /** * Enforce dot notation whenever possible * @see https://eslint.org/docs/latest/rules/dot-notation */ 'dot-notation'?: Linter.RuleEntry<DotNotation> /** * Require or disallow newline at the end of files * @see https://eslint.org/docs/latest/rules/eol-last * @deprecated */ 'eol-last'?: Linter.RuleEntry<EolLast> /** * Require the use of `===` and `!==` * @see https://eslint.org/docs/latest/rules/eqeqeq */ 'eqeqeq'?: Linter.RuleEntry<Eqeqeq> /** * Enforce `for` loop update clause moving the counter in the right direction * @see https://eslint.org/docs/latest/rules/for-direction */ 'for-direction'?: Linter.RuleEntry<[]> /** * Use dprint to format code */ 'format/dprint'?: Linter.RuleEntry<FormatDprint> /** * Use oxfmt to format code */ 'format/oxfmt'?: Linter.RuleEntry<FormatOxfmt> /** * Use Prettier to format code */ 'format/prettier'?: Linter.RuleEntry<FormatPrettier> /** * Require or disallow spacing between function identifiers and their invocations * @see https://eslint.org/docs/latest/rules/func-call-spacing * @deprecated */ 'func-call-spacing'?: Linter.RuleEntry<FuncCallSpacing> /** * Require function names to match the name of the variable or property to which they are assigned * @see https://eslint.org/docs/latest/rules/func-name-matching */ 'func-name-matching'?: Linter.RuleEntry<FuncNameMatching> /** * Require or disallow named `function` expressions * @see https://eslint.org/docs/latest/rules/func-names */ 'func-names'?: Linter.RuleEntry<FuncNames> /** * Enforce the consistent use of either `function` declarations or expressions assigned to variables * @see https://eslint.org/docs/latest/rules/func-style */ 'func-style'?: Linter.RuleEntry<FuncStyle> /** * Enforce line breaks between arguments of a function call * @see https://eslint.org/docs/latest/rules/function-call-argument-newline * @deprecated */ 'function-call-argument-newline'?: Linter.RuleEntry<FunctionCallArgumentNewline> /** * Enforce consistent line breaks inside function parentheses * @see https://eslint.org/docs/latest/rules/function-paren-newline * @deprecated */ 'function-paren-newline'?: Linter.RuleEntry<FunctionParenNewline> /** * Enforce consistent spacing around `*` operators in generator functions * @see https://eslint.org/docs/latest/rules/generator-star-spacing * @deprecated */ 'generator-star-spacing'?: Linter.RuleEntry<GeneratorStarSpacing> /** * Enforce `return` statements in getters * @see https://eslint.org/docs/latest/rules/getter-return */ 'getter-return'?: Linter.RuleEntry<GetterReturn> /** * Require `require()` calls to be placed at top-level module scope * @see https://eslint.org/docs/latest/rules/global-require * @deprecated */ 'global-require'?: Linter.RuleEntry<[]> /** * Enforce arrange in alphabetical order for type fields, enum values, input object fields, operation selections and more. * @see https://the-guild.dev/graphql/eslint/rules/alphabetize */ 'graphql/alphabetize'?: Linter.RuleEntry<GraphqlAlphabetize> /** * Require all comments to follow the same style (either block or inline). * @see https://the-guild.dev/graphql/eslint/rules/description-style */ 'graphql/description-style'?: Linter.RuleEntry<GraphqlDescriptionStyle> /** * A GraphQL document is only valid for execution if all definitions are either operation or fragment definitions. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/executable-definitions */ 'graphql/executable-definitions'?: Linter.RuleEntry<[]> /** * A GraphQL document is only valid if all fields selected are defined by the parent type, or are an allowed meta field such as `__typename`. > This rule is a wrapper around a `graphql-js` validation function. * @see https://the-guild.dev/graphql/eslint/rules/fields-on-correct-type */ 'graphql/fields-on-correct-type'?: Linter.RuleEntry<[]> /** * Fragments use a type condition to determine if they apply, since fragments can only be spread into a composite type (object, interface, or union), the type condition