",
+ type: "string",
+ enum: ["reactClassic"],
+ },
+ ],
+ },
+ Kind: {
+ oneOf: [
+ {
+ type: "string",
+ enum: [
+ "class",
+ "enum",
+ "interface",
+ "enumMember",
+ "importNamespace",
+ "exportNamespace",
+ "variable",
+ "const",
+ "let",
+ "using",
+ "var",
+ "catchParameter",
+ "indexParameter",
+ "exportAlias",
+ "importAlias",
+ "classGetter",
+ "classSetter",
+ "classMethod",
+ "objectLiteralProperty",
+ "objectLiteralGetter",
+ "objectLiteralSetter",
+ "objectLiteralMethod",
+ "typeAlias",
+ ],
+ },
+ { description: "All kinds", type: "string", enum: ["any"] },
+ {
+ description:
+ "All type definitions: classes, enums, interfaces, and type aliases",
+ type: "string",
+ enum: ["typeLike"],
+ },
+ {
+ description: "Named function declarations and expressions",
+ type: "string",
+ enum: ["function"],
+ },
+ {
+ description: "TypeScript namespaces, import and export namespaces",
+ type: "string",
+ enum: ["namespaceLike"],
+ },
+ {
+ description: "TypeScript mamespaces",
+ type: "string",
+ enum: ["namespace"],
+ },
+ {
+ description: "All function parameters, but parameter properties",
+ type: "string",
+ enum: ["functionParameter"],
+ },
+ {
+ description: "All generic type parameters",
+ type: "string",
+ enum: ["typeParameter"],
+ },
+ {
+ description:
+ "All class members: properties, methods, getters, and setters",
+ type: "string",
+ enum: ["classMember"],
+ },
+ {
+ description: "All class properties, including parameter properties",
+ type: "string",
+ enum: ["classProperty"],
+ },
+ {
+ description:
+ "All object literal members: properties, methods, getters, and setters",
+ type: "string",
+ enum: ["objectLiteralMember"],
+ },
+ {
+ description: "All members defined in type alaises and interfaces",
+ type: "string",
+ enum: ["typeMember"],
+ },
+ {
+ description: "All getters defined in type alaises and interfaces",
+ type: "string",
+ enum: ["typeGetter"],
+ },
+ {
+ description:
+ "All properties defined in type alaises and interfaces",
+ type: "string",
+ enum: ["typeProperty"],
+ },
+ {
+ description: "All setters defined in type alaises and interfaces",
+ type: "string",
+ enum: ["typeSetter"],
+ },
+ {
+ description: "All methods defined in type alaises and interfaces",
+ type: "string",
+ enum: ["typeMethod"],
+ },
+ ],
+ },
+ LineEnding: {
+ oneOf: [
+ {
+ description:
+ "Line Feed only (\\n), common on Linux and macOS as well as inside git repos",
+ type: "string",
+ enum: ["lf"],
+ },
+ {
+ description:
+ "Carriage Return + Line Feed characters (\\r\\n), common on Windows",
+ type: "string",
+ enum: ["crlf"],
+ },
+ {
+ description:
+ "Carriage Return character only (\\r), used very rarely",
+ type: "string",
+ enum: ["cr"],
+ },
+ ],
+ },
+ LineWidth: {
+ description:
+ "Validated value for the `line_width` formatter options\n\nThe allowed range of values is 1..=320",
+ type: "integer",
+ format: "uint16",
+ minimum: 0.0,
+ },
+ LinterConfiguration: {
+ type: "object",
+ properties: {
+ enabled: {
+ description:
+ "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+ type: ["boolean", "null"],
+ },
+ ignore: {
+ description:
+ "A list of Unix shell style patterns. The formatter will ignore files/folders that will match these patterns.",
+ anyOf: [{ $ref: "#/definitions/StringSet" }, { type: "null" }],
+ },
+ include: {
+ description:
+ "A list of Unix shell style patterns. The formatter will include files/folders that will match these patterns.",
+ anyOf: [{ $ref: "#/definitions/StringSet" }, { type: "null" }],
+ },
+ rules: {
+ description: "List of rules",
+ anyOf: [{ $ref: "#/definitions/Rules" }, { type: "null" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ Modifiers: {
+ type: "array",
+ items: { $ref: "#/definitions/RestrictedModifier" },
+ uniqueItems: true,
+ },
+ NamingConventionConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithNamingConventionOptions" },
+ ],
+ },
+ NamingConventionOptions: {
+ description: "Rule's options.",
+ type: "object",
+ properties: {
+ conventions: {
+ description: "Custom conventions.",
+ type: "array",
+ items: { $ref: "#/definitions/Convention" },
+ },
+ enumMemberCase: {
+ description: "Allowed cases for _TypeScript_ `enum` member names.",
+ allOf: [{ $ref: "#/definitions/Format" }],
+ },
+ requireAscii: {
+ description: "If `false`, then non-ASCII characters are allowed.",
+ type: "boolean",
+ },
+ strictCase: {
+ description:
+ "If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].",
+ type: "boolean",
+ },
+ },
+ additionalProperties: false,
+ },
+ NoConsoleConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithNoConsoleOptions" },
+ ],
+ },
+ NoConsoleOptions: {
+ type: "object",
+ required: ["allow"],
+ properties: {
+ allow: {
+ description: "Allowed calls on the console object.",
+ type: "array",
+ items: { type: "string" },
+ },
+ },
+ additionalProperties: false,
+ },
+ NoDoubleEqualsConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithNoDoubleEqualsOptions" },
+ ],
+ },
+ NoDoubleEqualsOptions: {
+ description: "Rule's options",
+ type: "object",
+ properties: {
+ ignoreNull: {
+ description:
+ "If `true`, an exception is made when comparing with `null`, as it's often relied on to check both for `null` or `undefined`.\n\nIf `false`, no such exception will be made.",
+ type: "boolean",
+ },
+ },
+ additionalProperties: false,
+ },
+ NoLabelWithoutControlConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithNoLabelWithoutControlOptions" },
+ ],
+ },
+ NoLabelWithoutControlOptions: {
+ type: "object",
+ required: ["inputComponents", "labelAttributes", "labelComponents"],
+ properties: {
+ inputComponents: {
+ description:
+ "Array of component names that should be considered the same as an `input` element.",
+ type: "array",
+ items: { type: "string" },
+ },
+ labelAttributes: {
+ description:
+ "Array of attributes that should be treated as the `label` accessible text content.",
+ type: "array",
+ items: { type: "string" },
+ },
+ labelComponents: {
+ description:
+ "Array of component names that should be considered the same as a `label` element.",
+ type: "array",
+ items: { type: "string" },
+ },
+ },
+ additionalProperties: false,
+ },
+ NoRestrictedTypesConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithNoRestrictedTypesOptions" },
+ ],
+ },
+ NoRestrictedTypesOptions: {
+ type: "object",
+ required: ["types"],
+ properties: {
+ types: {
+ type: "object",
+ additionalProperties: {
+ $ref: "#/definitions/CustomRestrictedType",
+ },
+ },
+ },
+ additionalProperties: false,
+ },
+ Nursery: {
+ description: "A list of rules that belong to this group",
+ type: "object",
+ properties: {
+ all: {
+ description: "It enables ALL rules for this group.",
+ type: ["boolean", "null"],
+ },
+ noCommonJs: {
+ description:
+ "Disallow use of CommonJs module system in favor of ESM style imports.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noConsole: {
+ description: "Disallow the use of console.",
+ anyOf: [
+ { $ref: "#/definitions/NoConsoleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDoneCallback: {
+ description:
+ "Disallow using a callback in asynchronous tests and hooks.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateAtImportRules: {
+ description: "Disallow duplicate @import rules.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateCustomProperties: {
+ description:
+ "Disallow duplicate custom properties within declaration blocks.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateElseIf: {
+ description: "Disallow duplicate conditions in if-else-if chains",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateFontNames: {
+ description: "Disallow duplicate names within font families.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateSelectorsKeyframeBlock: {
+ description: "Disallow duplicate selectors within keyframe blocks.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicatedFields: {
+ description: "No duplicated fields in GraphQL operations.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDynamicNamespaceImportAccess: {
+ description: "Disallow accessing namespace imports dynamically.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noEmptyBlock: {
+ description: "Disallow CSS empty blocks.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noEnum: {
+ description: "Disallow TypeScript enum.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noEvolvingTypes: {
+ description:
+ "Disallow variables from evolving into any type through reassignments.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noExportedImports: {
+ description: "Disallow exporting an imported variable.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noImportantInKeyframe: {
+ description:
+ "Disallow invalid !important within keyframe declarations",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noInvalidDirectionInLinearGradient: {
+ description:
+ "Disallow non-standard direction values for linear gradient functions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noInvalidGridAreas: {
+ description:
+ "Disallows invalid named grid areas in CSS Grid Layouts.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noInvalidPositionAtImportRule: {
+ description:
+ "Disallow the use of @import at-rules in invalid positions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noIrregularWhitespace: {
+ description:
+ "Disallows the use of irregular whitespace characters.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noLabelWithoutControl: {
+ description:
+ "Enforce that a label element or component has a text label and an associated input.",
+ anyOf: [
+ { $ref: "#/definitions/NoLabelWithoutControlConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noMisplacedAssertion: {
+ description:
+ "Checks that the assertion function, for example expect, is placed inside an it() function call.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noReactSpecificProps: {
+ description:
+ "Prevents React-specific JSX properties from being used.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noRestrictedImports: {
+ description:
+ "Disallow specified modules when loaded by import or require.",
+ anyOf: [
+ { $ref: "#/definitions/RestrictedImportsConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noRestrictedTypes: {
+ description: "Disallow user defined types.",
+ anyOf: [
+ { $ref: "#/definitions/NoRestrictedTypesConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noSecrets: {
+ description:
+ "Disallow usage of sensitive data such as API keys and tokens.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noShorthandPropertyOverrides: {
+ description:
+ "Disallow shorthand properties that override related longhand properties.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noStaticElementInteractions: {
+ description:
+ "Enforce that static, visible elements (such as \\) that have click handlers use the valid role attribute.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noSubstr: {
+ description:
+ "Enforce the use of String.slice() over String.substr() and String.substring().",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUndeclaredDependencies: {
+ description:
+ "Disallow the use of dependencies that aren't specified in the package.json.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnknownFunction: {
+ description: "Disallow unknown CSS value functions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnknownMediaFeatureName: {
+ description: "Disallow unknown media feature names.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnknownProperty: {
+ description: "Disallow unknown properties.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnknownPseudoClass: {
+ description: "Disallow unknown pseudo-class selectors.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnknownPseudoElement: {
+ description: "Disallow unknown pseudo-element selectors.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnknownUnit: {
+ description: "Disallow unknown CSS units.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnmatchableAnbSelector: {
+ description: "Disallow unmatchable An+B selectors.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnusedFunctionParameters: {
+ description: "Disallow unused function parameters.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUselessEscapeInRegex: {
+ description:
+ "Disallow unnecessary escape sequence in regular expression literals.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUselessStringConcat: {
+ description:
+ "Disallow unnecessary concatenation of string or template literals.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUselessUndefinedInitialization: {
+ description: "Disallow initializing variables to undefined.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noValueAtRule: {
+ description: "Disallow use of @value rule in css modules.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noYodaExpression: {
+ description: "Disallow the use of yoda expressions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ recommended: {
+ description: "It enables the recommended rules for this group",
+ type: ["boolean", "null"],
+ },
+ useAdjacentOverloadSignatures: {
+ description:
+ "Disallow the use of overload signatures that are not next to each other.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useAriaPropsSupportedByRole: {
+ description:
+ "Enforce that ARIA properties are valid for the roles that are supported by the element.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useConsistentBuiltinInstantiation: {
+ description:
+ "Enforce the use of new for all builtins, except String, Number, Boolean, Symbol and BigInt.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useConsistentCurlyBraces: {
+ description:
+ "This rule enforces consistent use of curly braces inside JSX attributes and JSX children.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useConsistentMemberAccessibility: {
+ description:
+ "Require consistent accessibility modifiers on class properties and methods.",
+ anyOf: [
+ {
+ $ref: "#/definitions/ConsistentMemberAccessibilityConfiguration",
+ },
+ { type: "null" },
+ ],
+ },
+ useDateNow: {
+ description:
+ "Use Date.now() to get the number of milliseconds since the Unix Epoch.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useDefaultSwitchClause: {
+ description: "Require the default clause in switch statements.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useDeprecatedReason: {
+ description:
+ "Require specifying the reason argument when using @deprecated directive",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useErrorMessage: {
+ description:
+ "Enforce passing a message value when creating a built-in error.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useExplicitLengthCheck: {
+ description:
+ "Enforce explicitly comparing the length, size, byteLength or byteOffset property of a value.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useFocusableInteractive: {
+ description:
+ "Elements with an interactive role and interaction handlers must be focusable.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useGenericFontNames: {
+ description:
+ "Disallow a missing generic family keyword within font families.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useImportExtensions: {
+ description: "Enforce file extensions for relative imports.",
+ anyOf: [
+ { $ref: "#/definitions/UseImportExtensionsConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useImportRestrictions: {
+ description: "Disallows package private imports.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNumberToFixedDigitsArgument: {
+ description:
+ "Enforce using the digits argument with Number#toFixed().",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useSemanticElements: {
+ description:
+ "It detects the use of role attributes in JSX elements and suggests using semantic elements instead.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useSortedClasses: {
+ description: "Enforce the sorting of CSS utility classes.",
+ anyOf: [
+ { $ref: "#/definitions/UtilityClassSortingConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useStrictMode: {
+ description:
+ 'Enforce the use of the directive "use strict" in script files.',
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useThrowNewError: {
+ description: "Require new when throwing an error.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useThrowOnlyError: {
+ description: "Disallow throwing non-Error values.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useTopLevelRegex: {
+ description:
+ "Require regex literals to be declared at the top level.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useTrimStartEnd: {
+ description:
+ "Enforce the use of String.trimStart() and String.trimEnd() over String.trimLeft() and String.trimRight().",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useValidAutocomplete: {
+ description:
+ "Use valid values for the autocomplete attribute on input elements.",
+ anyOf: [
+ { $ref: "#/definitions/UseValidAutocompleteConfiguration" },
+ { type: "null" },
+ ],
+ },
+ },
+ additionalProperties: false,
+ },
+ OrganizeImports: {
+ type: "object",
+ properties: {
+ enabled: {
+ description: "Enables the organization of imports",
+ type: ["boolean", "null"],
+ },
+ ignore: {
+ description:
+ "A list of Unix shell style patterns. The formatter will ignore files/folders that will match these patterns.",
+ anyOf: [{ $ref: "#/definitions/StringSet" }, { type: "null" }],
+ },
+ include: {
+ description:
+ "A list of Unix shell style patterns. The formatter will include files/folders that will match these patterns.",
+ anyOf: [{ $ref: "#/definitions/StringSet" }, { type: "null" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ OverrideFormatterConfiguration: {
+ type: "object",
+ properties: {
+ attributePosition: {
+ description: "The attribute position style.",
+ anyOf: [
+ { $ref: "#/definitions/AttributePosition" },
+ { type: "null" },
+ ],
+ },
+ bracketSpacing: {
+ description:
+ "Whether to insert spaces around brackets in object literals. Defaults to true.",
+ anyOf: [{ $ref: "#/definitions/BracketSpacing" }, { type: "null" }],
+ },
+ enabled: { type: ["boolean", "null"] },
+ formatWithErrors: {
+ description:
+ "Stores whether formatting should be allowed to proceed if a given file has syntax errors",
+ type: ["boolean", "null"],
+ },
+ indentSize: {
+ description:
+ "The size of the indentation, 2 by default (deprecated, use `indent-width`)",
+ anyOf: [{ $ref: "#/definitions/IndentWidth" }, { type: "null" }],
+ },
+ indentStyle: {
+ description: "The indent style.",
+ anyOf: [{ $ref: "#/definitions/IndentStyle" }, { type: "null" }],
+ },
+ indentWidth: {
+ description: "The size of the indentation, 2 by default",
+ anyOf: [{ $ref: "#/definitions/IndentWidth" }, { type: "null" }],
+ },
+ lineEnding: {
+ description: "The type of line ending.",
+ anyOf: [{ $ref: "#/definitions/LineEnding" }, { type: "null" }],
+ },
+ lineWidth: {
+ description: "What's the max width of a line. Defaults to 80.",
+ anyOf: [{ $ref: "#/definitions/LineWidth" }, { type: "null" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ OverrideLinterConfiguration: {
+ type: "object",
+ properties: {
+ enabled: {
+ description:
+ "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+ type: ["boolean", "null"],
+ },
+ rules: {
+ description: "List of rules",
+ anyOf: [{ $ref: "#/definitions/Rules" }, { type: "null" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ OverrideOrganizeImportsConfiguration: {
+ type: "object",
+ properties: {
+ enabled: {
+ description:
+ "if `false`, it disables the feature and the linter won't be executed. `true` by default",
+ type: ["boolean", "null"],
+ },
+ },
+ additionalProperties: false,
+ },
+ OverridePattern: {
+ type: "object",
+ properties: {
+ css: {
+ description: "Specific configuration for the Css language",
+ anyOf: [
+ { $ref: "#/definitions/CssConfiguration" },
+ { type: "null" },
+ ],
+ },
+ formatter: {
+ description: "Specific configuration for the Json language",
+ anyOf: [
+ { $ref: "#/definitions/OverrideFormatterConfiguration" },
+ { type: "null" },
+ ],
+ },
+ graphql: {
+ description: "Specific configuration for the Graphql language",
+ anyOf: [
+ { $ref: "#/definitions/GraphqlConfiguration" },
+ { type: "null" },
+ ],
+ },
+ ignore: {
+ description:
+ "A list of Unix shell style patterns. The formatter will ignore files/folders that will match these patterns.",
+ anyOf: [{ $ref: "#/definitions/StringSet" }, { type: "null" }],
+ },
+ include: {
+ description:
+ "A list of Unix shell style patterns. The formatter will include files/folders that will match these patterns.",
+ anyOf: [{ $ref: "#/definitions/StringSet" }, { type: "null" }],
+ },
+ javascript: {
+ description: "Specific configuration for the JavaScript language",
+ anyOf: [
+ { $ref: "#/definitions/JavascriptConfiguration" },
+ { type: "null" },
+ ],
+ },
+ json: {
+ description: "Specific configuration for the Json language",
+ anyOf: [
+ { $ref: "#/definitions/JsonConfiguration" },
+ { type: "null" },
+ ],
+ },
+ linter: {
+ description: "Specific configuration for the Json language",
+ anyOf: [
+ { $ref: "#/definitions/OverrideLinterConfiguration" },
+ { type: "null" },
+ ],
+ },
+ organizeImports: {
+ description: "Specific configuration for the Json language",
+ anyOf: [
+ { $ref: "#/definitions/OverrideOrganizeImportsConfiguration" },
+ { type: "null" },
+ ],
+ },
+ },
+ additionalProperties: false,
+ },
+ Overrides: {
+ type: "array",
+ items: { $ref: "#/definitions/OverridePattern" },
+ },
+ Performance: {
+ description: "A list of rules that belong to this group",
+ type: "object",
+ properties: {
+ all: {
+ description: "It enables ALL rules for this group.",
+ type: ["boolean", "null"],
+ },
+ noAccumulatingSpread: {
+ description:
+ "Disallow the use of spread (...) syntax on accumulators.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noBarrelFile: {
+ description: "Disallow the use of barrel file.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDelete: {
+ description: "Disallow the use of the delete operator.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noReExportAll: {
+ description: "Avoid re-export all.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ recommended: {
+ description: "It enables the recommended rules for this group",
+ type: ["boolean", "null"],
+ },
+ },
+ additionalProperties: false,
+ },
+ QuoteProperties: { type: "string", enum: ["asNeeded", "preserve"] },
+ QuoteStyle: { type: "string", enum: ["double", "single"] },
+ Regex: { type: "string" },
+ RestrictedGlobalsConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithRestrictedGlobalsOptions" },
+ ],
+ },
+ RestrictedGlobalsOptions: {
+ description: "Options for the rule `noRestrictedGlobals`.",
+ type: "object",
+ required: ["deniedGlobals"],
+ properties: {
+ deniedGlobals: {
+ description: "A list of names that should trigger the rule",
+ type: "array",
+ items: { type: "string" },
+ },
+ },
+ additionalProperties: false,
+ },
+ RestrictedImportsConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithRestrictedImportsOptions" },
+ ],
+ },
+ RestrictedImportsOptions: {
+ description: "Options for the rule `noRestrictedImports`.",
+ type: "object",
+ required: ["paths"],
+ properties: {
+ paths: {
+ description: "A list of names that should trigger the rule",
+ type: "object",
+ additionalProperties: { type: "string" },
+ },
+ },
+ additionalProperties: false,
+ },
+ RestrictedModifier: {
+ type: "string",
+ enum: ["abstract", "private", "protected", "readonly", "static"],
+ },
+ RuleAssistConfiguration: { type: "string", enum: ["on", "off"] },
+ RuleConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithNoOptions" },
+ ],
+ },
+ RuleFixConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithFixNoOptions" },
+ ],
+ },
+ RulePlainConfiguration: {
+ type: "string",
+ enum: ["warn", "error", "info", "off"],
+ },
+ RuleWithAllowDomainOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/AllowDomainOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithComplexityOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/ComplexityOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithConsistentArrayTypeOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/ConsistentArrayTypeOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithConsistentMemberAccessibilityOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [
+ { $ref: "#/definitions/ConsistentMemberAccessibilityOptions" },
+ ],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithDeprecatedHooksOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/DeprecatedHooksOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithFilenamingConventionOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/FilenamingConventionOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithFixNoOptions: {
+ type: "object",
+ required: ["level"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithHooksOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/HooksOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithNamingConventionOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/NamingConventionOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithNoConsoleOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/NoConsoleOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithNoDoubleEqualsOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/NoDoubleEqualsOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithNoLabelWithoutControlOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/NoLabelWithoutControlOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithNoOptions: {
+ type: "object",
+ required: ["level"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithNoRestrictedTypesOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/NoRestrictedTypesOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithRestrictedGlobalsOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/RestrictedGlobalsOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithRestrictedImportsOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/RestrictedImportsOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithUseImportExtensionsOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/UseImportExtensionsOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithUseValidAutocompleteOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/UseValidAutocompleteOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithUtilityClassSortingOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/UtilityClassSortingOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ RuleWithValidAriaRoleOptions: {
+ type: "object",
+ required: ["level", "options"],
+ properties: {
+ fix: {
+ description: "The kind of the code actions emitted by the rule",
+ anyOf: [{ $ref: "#/definitions/FixKind" }, { type: "null" }],
+ },
+ level: {
+ description: "The severity of the emitted diagnostics by the rule",
+ allOf: [{ $ref: "#/definitions/RulePlainConfiguration" }],
+ },
+ options: {
+ description: "Rule's options",
+ allOf: [{ $ref: "#/definitions/ValidAriaRoleOptions" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ Rules: {
+ type: "object",
+ properties: {
+ a11y: {
+ anyOf: [{ $ref: "#/definitions/A11y" }, { type: "null" }],
+ },
+ all: {
+ description:
+ "It enables ALL rules. The rules that belong to `nursery` won't be enabled.",
+ type: ["boolean", "null"],
+ },
+ complexity: {
+ anyOf: [{ $ref: "#/definitions/Complexity" }, { type: "null" }],
+ },
+ correctness: {
+ anyOf: [{ $ref: "#/definitions/Correctness" }, { type: "null" }],
+ },
+ nursery: {
+ anyOf: [{ $ref: "#/definitions/Nursery" }, { type: "null" }],
+ },
+ performance: {
+ anyOf: [{ $ref: "#/definitions/Performance" }, { type: "null" }],
+ },
+ recommended: {
+ description:
+ "It enables the lint rules recommended by Biome. `true` by default.",
+ type: ["boolean", "null"],
+ },
+ security: {
+ anyOf: [{ $ref: "#/definitions/Security" }, { type: "null" }],
+ },
+ style: {
+ anyOf: [{ $ref: "#/definitions/Style" }, { type: "null" }],
+ },
+ suspicious: {
+ anyOf: [{ $ref: "#/definitions/Suspicious" }, { type: "null" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ Scope: { type: "string", enum: ["any", "global"] },
+ Security: {
+ description: "A list of rules that belong to this group",
+ type: "object",
+ properties: {
+ all: {
+ description: "It enables ALL rules for this group.",
+ type: ["boolean", "null"],
+ },
+ noDangerouslySetInnerHtml: {
+ description: "Prevent the usage of dangerous JSX props",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDangerouslySetInnerHtmlWithChildren: {
+ description:
+ "Report when a DOM element or a component uses both children and dangerouslySetInnerHTML prop.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noGlobalEval: {
+ description: "Disallow the use of global eval().",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ recommended: {
+ description: "It enables the recommended rules for this group",
+ type: ["boolean", "null"],
+ },
+ },
+ additionalProperties: false,
+ },
+ Selector: {
+ type: "object",
+ properties: {
+ kind: {
+ description: "Declaration kind",
+ allOf: [{ $ref: "#/definitions/Kind" }],
+ },
+ modifiers: {
+ description: "Modifiers used on the declaration",
+ allOf: [{ $ref: "#/definitions/Modifiers" }],
+ },
+ scope: {
+ description: "Scope of the declaration",
+ allOf: [{ $ref: "#/definitions/Scope" }],
+ },
+ },
+ additionalProperties: false,
+ },
+ Semicolons: { type: "string", enum: ["always", "asNeeded"] },
+ Source: {
+ description: "A list of rules that belong to this group",
+ type: "object",
+ properties: {
+ sortJsxProps: {
+ description: "Enforce props sorting in JSX elements.",
+ anyOf: [
+ { $ref: "#/definitions/RuleAssistConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useSortedKeys: {
+ description: "Sorts the keys of a JSON object in natural order",
+ anyOf: [
+ { $ref: "#/definitions/RuleAssistConfiguration" },
+ { type: "null" },
+ ],
+ },
+ },
+ additionalProperties: false,
+ },
+ StableHookResult: {
+ oneOf: [
+ {
+ description: "Whether the hook has a stable result.",
+ type: "boolean",
+ },
+ {
+ description:
+ "Used to indicate the hook returns an array and some of its indices have stable identities.",
+ type: "array",
+ items: {
+ type: "integer",
+ format: "uint8",
+ maximum: 255.0,
+ minimum: 0.0,
+ },
+ minItems: 1,
+ },
+ ],
+ },
+ StringSet: {
+ type: "array",
+ items: { type: "string" },
+ uniqueItems: true,
+ },
+ Style: {
+ description: "A list of rules that belong to this group",
+ type: "object",
+ properties: {
+ all: {
+ description: "It enables ALL rules for this group.",
+ type: ["boolean", "null"],
+ },
+ noArguments: {
+ description: "Disallow the use of arguments.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noCommaOperator: {
+ description: "Disallow comma operator.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDefaultExport: {
+ description: "Disallow default exports.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noImplicitBoolean: {
+ description:
+ "Disallow implicit true values on JSX boolean attributes",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noInferrableTypes: {
+ description:
+ "Disallow type annotations for variables, parameters, and class properties initialized with a literal expression.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noNamespace: {
+ description: "Disallow the use of TypeScript's namespaces.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noNamespaceImport: {
+ description: "Disallow the use of namespace imports.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noNegationElse: {
+ description:
+ "Disallow negation in the condition of an if statement if it has an else clause.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noNonNullAssertion: {
+ description:
+ "Disallow non-null assertions using the ! postfix operator.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noParameterAssign: {
+ description: "Disallow reassigning function parameters.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noParameterProperties: {
+ description:
+ "Disallow the use of parameter properties in class constructors.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noRestrictedGlobals: {
+ description:
+ "This rule allows you to specify global variable names that you donโt want to use in your application.",
+ anyOf: [
+ { $ref: "#/definitions/RestrictedGlobalsConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noShoutyConstants: {
+ description:
+ "Disallow the use of constants which its value is the upper-case version of its name.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnusedTemplateLiteral: {
+ description:
+ "Disallow template literals if interpolation and special-character handling are not needed",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUselessElse: {
+ description: "Disallow else block when the if block breaks early.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noVar: {
+ description: "Disallow the use of var",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ recommended: {
+ description: "It enables the recommended rules for this group",
+ type: ["boolean", "null"],
+ },
+ useAsConstAssertion: {
+ description:
+ "Enforce the use of as const over literal type and type annotation.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useBlockStatements: {
+ description: "Requires following curly brace conventions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useCollapsedElseIf: {
+ description:
+ "Enforce using else if instead of nested if in else clauses.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useConsistentArrayType: {
+ description:
+ "Require consistently using either T\\[] or Array\\",
+ anyOf: [
+ { $ref: "#/definitions/ConsistentArrayTypeConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useConst: {
+ description:
+ "Require const declarations for variables that are only assigned once.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useDefaultParameterLast: {
+ description:
+ "Enforce default function parameters and optional function parameters to be last.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useEnumInitializers: {
+ description:
+ "Require that each enum member value be explicitly initialized.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useExponentiationOperator: {
+ description:
+ "Disallow the use of Math.pow in favor of the ** operator.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useExportType: {
+ description: "Promotes the use of export type for types.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useFilenamingConvention: {
+ description:
+ "Enforce naming conventions for JavaScript and TypeScript filenames.",
+ anyOf: [
+ { $ref: "#/definitions/FilenamingConventionConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useForOf: {
+ description:
+ "This rule recommends a for-of loop when in a for loop, the index used to extract an item from the iterated array.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useFragmentSyntax: {
+ description:
+ "This rule enforces the use of \\<>...\\ over \\...\\.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useImportType: {
+ description: "Promotes the use of import type for types.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useLiteralEnumMembers: {
+ description: "Require all enum members to be literal values.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNamingConvention: {
+ description:
+ "Enforce naming conventions for everything across a codebase.",
+ anyOf: [
+ { $ref: "#/definitions/NamingConventionConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNodeAssertStrict: {
+ description:
+ "Promotes the usage of node:assert/strict over node:assert.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNodejsImportProtocol: {
+ description:
+ "Enforces using the node: protocol for Node.js builtin modules.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNumberNamespace: {
+ description: "Use the Number properties instead of global ones.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNumericLiterals: {
+ description:
+ "Disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useSelfClosingElements: {
+ description:
+ "Prevent extra closing tags for components without children",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useShorthandArrayType: {
+ description:
+ "When expressing array types, this rule promotes the usage of T\\[] shorthand instead of Array\\.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useShorthandAssign: {
+ description:
+ "Require assignment operator shorthand where possible.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useShorthandFunctionType: {
+ description:
+ "Enforce using function types instead of object type with call signatures.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useSingleCaseStatement: {
+ description:
+ "Enforces switch clauses have a single statement, emits a quick fix wrapping the statements in a block.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useSingleVarDeclarator: {
+ description:
+ "Disallow multiple variable declarations in the same variable statement",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useTemplate: {
+ description: "Prefer template literals over string concatenation.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useWhile: {
+ description:
+ "Enforce the use of while loops instead of for loops when the initializer and update expressions are not needed.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ },
+ additionalProperties: false,
+ },
+ SuggestedExtensionMapping: {
+ type: "object",
+ required: ["component", "module"],
+ properties: {
+ component: {
+ description:
+ "Extension that should be used for component file imports",
+ type: "string",
+ },
+ module: {
+ description: "Extension that should be used for module imports",
+ type: "string",
+ },
+ },
+ additionalProperties: false,
+ },
+ Suspicious: {
+ description: "A list of rules that belong to this group",
+ type: "object",
+ properties: {
+ all: {
+ description: "It enables ALL rules for this group.",
+ type: ["boolean", "null"],
+ },
+ noApproximativeNumericConstant: {
+ description:
+ "Use standard constants instead of approximated literals.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noArrayIndexKey: {
+ description: "Discourage the usage of Array index in keys.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noAssignInExpressions: {
+ description: "Disallow assignments in expressions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noAsyncPromiseExecutor: {
+ description:
+ "Disallows using an async function as a Promise executor.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noCatchAssign: {
+ description: "Disallow reassigning exceptions in catch clauses.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noClassAssign: {
+ description: "Disallow reassigning class members.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noCommentText: {
+ description: "Prevent comments from being inserted as text nodes",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noCompareNegZero: {
+ description: "Disallow comparing against -0",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noConfusingLabels: {
+ description: "Disallow labeled statements that are not loops.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noConfusingVoidType: {
+ description:
+ "Disallow void type outside of generic or return types.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noConsoleLog: {
+ description: "Disallow the use of console.log",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noConstEnum: {
+ description: "Disallow TypeScript const enum",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noControlCharactersInRegex: {
+ description:
+ "Prevents from having control characters and some escape sequences that match control characters in regular expressions.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDebugger: {
+ description: "Disallow the use of debugger",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDoubleEquals: {
+ description: "Require the use of === and !==.",
+ anyOf: [
+ { $ref: "#/definitions/NoDoubleEqualsConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateCase: {
+ description: "Disallow duplicate case labels.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateClassMembers: {
+ description: "Disallow duplicate class members.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateJsxProps: {
+ description:
+ "Prevents JSX properties to be assigned multiple times.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateObjectKeys: {
+ description: "Disallow two keys with the same name inside objects.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateParameters: {
+ description: "Disallow duplicate function parameter name.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noDuplicateTestHooks: {
+ description: "A describe block should not contain duplicate hooks.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noEmptyBlockStatements: {
+ description: "Disallow empty block statements and static blocks.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noEmptyInterface: {
+ description: "Disallow the declaration of empty interfaces.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noExplicitAny: {
+ description: "Disallow the any type usage.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noExportsInTest: {
+ description:
+ "Disallow using export or module.exports in files containing tests",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noExtraNonNullAssertion: {
+ description:
+ "Prevents the wrong usage of the non-null assertion operator (!) in TypeScript files.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noFallthroughSwitchClause: {
+ description: "Disallow fallthrough of switch clauses.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noFocusedTests: {
+ description: "Disallow focused tests.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noFunctionAssign: {
+ description: "Disallow reassigning function declarations.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noGlobalAssign: {
+ description:
+ "Disallow assignments to native objects and read-only global variables.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noGlobalIsFinite: {
+ description: "Use Number.isFinite instead of global isFinite.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noGlobalIsNan: {
+ description: "Use Number.isNaN instead of global isNaN.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noImplicitAnyLet: {
+ description:
+ "Disallow use of implicit any type on variable declarations.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noImportAssign: {
+ description: "Disallow assigning to imported bindings",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noLabelVar: {
+ description: "Disallow labels that share a name with a variable",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noMisleadingCharacterClass: {
+ description:
+ "Disallow characters made with multiple code points in character class syntax.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noMisleadingInstantiator: {
+ description: "Enforce proper usage of new and constructor.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noMisrefactoredShorthandAssign: {
+ description:
+ "Disallow shorthand assign when variable appears on both sides.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noPrototypeBuiltins: {
+ description: "Disallow direct use of Object.prototype builtins.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noRedeclare: {
+ description:
+ "Disallow variable, function, class, and type redeclarations in the same scope.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noRedundantUseStrict: {
+ description: 'Prevents from having redundant "use strict".',
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noSelfCompare: {
+ description:
+ "Disallow comparisons where both sides are exactly the same.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noShadowRestrictedNames: {
+ description:
+ "Disallow identifiers from shadowing restricted names.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noSkippedTests: {
+ description: "Disallow disabled tests.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noSparseArray: {
+ description: "Disallow sparse arrays",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noSuspiciousSemicolonInJsx: {
+ description:
+ 'It detects possible "wrong" semicolons inside JSX elements.',
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noThenProperty: {
+ description: "Disallow then property.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnsafeDeclarationMerging: {
+ description:
+ "Disallow unsafe declaration merging between interfaces and classes.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ noUnsafeNegation: {
+ description: "Disallow using unsafe negation.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ recommended: {
+ description: "It enables the recommended rules for this group",
+ type: ["boolean", "null"],
+ },
+ useAwait: {
+ description: "Ensure async functions utilize await.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useDefaultSwitchClauseLast: {
+ description:
+ "Enforce default clauses in switch statements to be last",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useGetterReturn: {
+ description: "Enforce get methods to always return a value.",
+ anyOf: [
+ { $ref: "#/definitions/RuleConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useIsArray: {
+ description: "Use Array.isArray() instead of instanceof Array.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useNamespaceKeyword: {
+ description:
+ "Require using the namespace keyword over the module keyword to declare TypeScript namespaces.",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ useValidTypeof: {
+ description:
+ "This rule verifies the result of typeof $expr unary expressions is being compared to valid values, either string literals containing valid type names or other typeof expressions",
+ anyOf: [
+ { $ref: "#/definitions/RuleFixConfiguration" },
+ { type: "null" },
+ ],
+ },
+ },
+ additionalProperties: false,
+ },
+ TrailingCommas: {
+ description:
+ "Print trailing commas wherever possible in multi-line comma-separated syntactic structures.",
+ oneOf: [
+ {
+ description:
+ "Trailing commas wherever possible (including function parameters and calls).",
+ type: "string",
+ enum: ["all"],
+ },
+ {
+ description:
+ "Trailing commas where valid in ES5 (objects, arrays, etc.). No trailing commas in type parameters in TypeScript.",
+ type: "string",
+ enum: ["es5"],
+ },
+ {
+ description: "No trailing commas.",
+ type: "string",
+ enum: ["none"],
+ },
+ ],
+ },
+ TrailingCommas2: {
+ oneOf: [
+ {
+ description: "The formatter will remove the trailing commas",
+ type: "string",
+ enum: ["none"],
+ },
+ {
+ description: "The trailing commas are allowed and advised",
+ type: "string",
+ enum: ["all"],
+ },
+ ],
+ },
+ UseImportExtensionsConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithUseImportExtensionsOptions" },
+ ],
+ },
+ UseImportExtensionsOptions: {
+ type: "object",
+ required: ["suggestedExtensions"],
+ properties: {
+ suggestedExtensions: {
+ description:
+ "A map of custom import extension mappings, where the key is the inspected file extension, and the value is a pair of `module` extension and `component` import extension",
+ type: "object",
+ additionalProperties: {
+ $ref: "#/definitions/SuggestedExtensionMapping",
+ },
+ },
+ },
+ additionalProperties: false,
+ },
+ UseValidAutocompleteConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithUseValidAutocompleteOptions" },
+ ],
+ },
+ UseValidAutocompleteOptions: {
+ type: "object",
+ required: ["inputComponents"],
+ properties: {
+ inputComponents: {
+ description:
+ "`input` like custom components that should be checked.",
+ type: "array",
+ items: { type: "string" },
+ },
+ },
+ additionalProperties: false,
+ },
+ UtilityClassSortingConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithUtilityClassSortingOptions" },
+ ],
+ },
+ UtilityClassSortingOptions: {
+ type: "object",
+ properties: {
+ attributes: {
+ description: "Additional attributes that will be sorted.",
+ type: ["array", "null"],
+ items: { type: "string" },
+ },
+ functions: {
+ description:
+ "Names of the functions or tagged templates that will be sorted.",
+ type: ["array", "null"],
+ items: { type: "string" },
+ },
+ },
+ additionalProperties: false,
+ },
+ ValidAriaRoleConfiguration: {
+ anyOf: [
+ { $ref: "#/definitions/RulePlainConfiguration" },
+ { $ref: "#/definitions/RuleWithValidAriaRoleOptions" },
+ ],
+ },
+ ValidAriaRoleOptions: {
+ type: "object",
+ required: ["allowInvalidRoles", "ignoreNonDom"],
+ properties: {
+ allowInvalidRoles: { type: "array", items: { type: "string" } },
+ ignoreNonDom: { type: "boolean" },
+ },
+ additionalProperties: false,
+ },
+ VcsClientKind: {
+ oneOf: [
+ {
+ description: "Integration with the git client as VCS",
+ type: "string",
+ enum: ["git"],
+ },
+ ],
+ },
+ VcsConfiguration: {
+ description:
+ "Set of properties to integrate Biome with a VCS software.",
+ type: "object",
+ properties: {
+ clientKind: {
+ description: "The kind of client.",
+ anyOf: [{ $ref: "#/definitions/VcsClientKind" }, { type: "null" }],
+ },
+ defaultBranch: {
+ description: "The main branch of the project",
+ type: ["string", "null"],
+ },
+ enabled: {
+ description:
+ "Whether Biome should integrate itself with the VCS client",
+ type: ["boolean", "null"],
+ },
+ root: {
+ description:
+ "The folder where Biome should check for VCS files. By default, Biome will use the same folder where `biome.json` was found.\n\nIf Biome can't find the configuration, it will attempt to use the current working directory. If no current working directory can't be found, Biome won't use the VCS integration, and a diagnostic will be emitted",
+ type: ["string", "null"],
+ },
+ useIgnoreFile: {
+ description:
+ "Whether Biome should use the VCS ignore file. When [true], Biome will ignore the files specified in the ignore file.",
+ type: ["boolean", "null"],
+ },
+ },
+ additionalProperties: false,
+ },
+ },
+ };
+ return new Response(JSON.stringify(schema), {
+ status: 200,
+ headers: {
+ "content-type": "application/json",
+ },
+ });
+}