@biomejs/wasm-nodejs 1.5.3-nightly.dca6a7a → 1.6.0

package/biome_wasm.d.ts

@@ -5,10 +5,10 @@
 export function main(): void;
 interface SupportsFeatureParams {
 	feature: FeatureName[];
-	path: RomePath;
+	path: BiomePath;
 }
 type FeatureName = "Format" | "Lint" | "OrganizeImports";
-interface RomePath {
+interface BiomePath {
 	path: string;
 }
 interface SupportsFeatureResult {
@@ -357,6 +357,10 @@ interface PartialJsonFormatter {
 	 * What's the max width of a line applied to JSON (and its super languages) files. Defaults to 80.
 	 */
 	lineWidth?: LineWidth;
+	/**
+	 * Print trailing commas wherever possible in multi-line comma-separated syntactic structures. Defaults to "none".
+	 */
+	trailingCommas?: TrailingCommas;
 }
 interface PartialJsonParser {
 	/**
@@ -426,6 +430,7 @@ type ArrowParentheses = "always" | "asNeeded";
 type QuoteProperties = "asNeeded" | "preserve";
 type Semicolons = "always" | "asNeeded";
 type TrailingComma = "all" | "es5" | "none";
+type TrailingCommas = "none" | "all";
 interface A11y {
 	/**
 	 * It enables ALL rules for this group.
@@ -434,59 +439,59 @@ interface A11y {
 	/**
 	 * Enforce that the accessKey attribute is not used on any HTML element.
 	 */
-	noAccessKey?: RuleConfiguration;
+	noAccessKey?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that aria-hidden="true" is not set on focusable elements.
 	 */
-	noAriaHiddenOnFocusable?: RuleConfiguration;
+	noAriaHiddenOnFocusable?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.
 	 */
-	noAriaUnsupportedElements?: RuleConfiguration;
+	noAriaUnsupportedElements?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that autoFocus prop is not used on elements.
 	 */
-	noAutofocus?: RuleConfiguration;
+	noAutofocus?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow target="_blank" attribute without rel="noreferrer"
 	 */
-	noBlankTarget?: RuleConfiguration;
+	noBlankTarget?: RuleConfiguration_for_Null;
 	/**
 	 * Enforces that no distracting elements are used.
 	 */
-	noDistractingElements?: RuleConfiguration;
+	noDistractingElements?: RuleConfiguration_for_Null;
 	/**
 	 * The scope prop should be used only on <th> elements.
 	 */
-	noHeaderScope?: RuleConfiguration;
+	noHeaderScope?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that non-interactive ARIA roles are not assigned to interactive HTML elements.
 	 */
-	noInteractiveElementToNoninteractiveRole?: RuleConfiguration;
+	noInteractiveElementToNoninteractiveRole?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that interactive ARIA roles are not assigned to non-interactive HTML elements.
 	 */
-	noNoninteractiveElementToInteractiveRole?: RuleConfiguration;
+	noNoninteractiveElementToInteractiveRole?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that tabIndex is not assigned to non-interactive HTML elements.
 	 */
-	noNoninteractiveTabindex?: RuleConfiguration;
+	noNoninteractiveTabindex?: RuleConfiguration_for_Null;
 	/**
 	 * Prevent the usage of positive integers on tabIndex property
 	 */
-	noPositiveTabindex?: RuleConfiguration;
+	noPositiveTabindex?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce img alt prop does not contain the word "image", "picture", or "photo".
 	 */
-	noRedundantAlt?: RuleConfiguration;
+	noRedundantAlt?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce explicit role property is not the same as implicit/default role property on an element.
 	 */
-	noRedundantRoles?: RuleConfiguration;
+	noRedundantRoles?: RuleConfiguration_for_Null;
 	/**
 	 * Enforces the usage of the title element for the svg element.
 	 */
-	noSvgWithoutTitle?: RuleConfiguration;
+	noSvgWithoutTitle?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
@@ -494,67 +499,67 @@ interface A11y {
 	/**
 	 * Enforce that all elements that require alternative text have meaningful information to relay back to the end user.
 	 */
-	useAltText?: RuleConfiguration;
+	useAltText?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that anchors have content and that the content is accessible to screen readers.
 	 */
-	useAnchorContent?: RuleConfiguration;
+	useAnchorContent?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that tabIndex is assigned to non-interactive HTML elements with aria-activedescendant.
 	 */
-	useAriaActivedescendantWithTabindex?: RuleConfiguration;
+	useAriaActivedescendantWithTabindex?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that elements with ARIA roles must have all required ARIA attributes for that role.
 	 */
-	useAriaPropsForRole?: RuleConfiguration;
+	useAriaPropsForRole?: RuleConfiguration_for_Null;
 	/**
 	 * Enforces the usage of the attribute type for the element button
 	 */
-	useButtonType?: RuleConfiguration;
+	useButtonType?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that heading elements (h1, h2, etc.) have content and that the content is accessible to screen readers. Accessible means that it is not hidden using the aria-hidden prop.
 	 */
-	useHeadingContent?: RuleConfiguration;
+	useHeadingContent?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that html element has lang attribute.
 	 */
-	useHtmlLang?: RuleConfiguration;
+	useHtmlLang?: RuleConfiguration_for_Null;
 	/**
 	 * Enforces the usage of the attribute title for the element iframe.
 	 */
-	useIframeTitle?: RuleConfiguration;
+	useIframeTitle?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce onClick is accompanied by at least one of the following: onKeyUp, onKeyDown, onKeyPress.
 	 */
-	useKeyWithClickEvents?: RuleConfiguration;
+	useKeyWithClickEvents?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce onMouseOver / onMouseOut are accompanied by onFocus / onBlur.
 	 */
-	useKeyWithMouseEvents?: RuleConfiguration;
+	useKeyWithMouseEvents?: RuleConfiguration_for_Null;
 	/**
 	 * Enforces that audio and video elements must have a track for captions.
 	 */
-	useMediaCaption?: RuleConfiguration;
+	useMediaCaption?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce that all anchors are valid, and they are navigable elements.
 	 */
-	useValidAnchor?: RuleConfiguration;
+	useValidAnchor?: RuleConfiguration_for_Null;
 	/**
 	 * Ensures that ARIA properties aria-* are all valid.
 	 */
-	useValidAriaProps?: RuleConfiguration;
+	useValidAriaProps?: RuleConfiguration_for_Null;
 	/**
 	 * Elements with ARIA roles must use a valid, non-abstract ARIA role.
 	 */
-	useValidAriaRole?: RuleConfiguration;
+	useValidAriaRole?: RuleConfiguration_for_ValidAriaRoleOptions;
 	/**
 	 * Enforce that ARIA state and property values are valid.
 	 */
-	useValidAriaValues?: RuleConfiguration;
+	useValidAriaValues?: RuleConfiguration_for_Null;
 	/**
 	 * Ensure that the attribute passed to the lang attribute is a correct ISO language and/or country.
 	 */
-	useValidLang?: RuleConfiguration;
+	useValidLang?: RuleConfiguration_for_Null;
 }
 interface Complexity {
 	/**
@@ -564,75 +569,83 @@ interface Complexity {
 	/**
 	 * Disallow primitive type aliases and misleading types.
 	 */
-	noBannedTypes?: RuleConfiguration;
+	noBannedTypes?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow empty type parameters in type aliases and interfaces.
+	 */
+	noEmptyTypeParameters?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow functions that exceed a given Cognitive Complexity score.
 	 */
-	noExcessiveCognitiveComplexity?: RuleConfiguration;
+	noExcessiveCognitiveComplexity?: RuleConfiguration_for_ComplexityOptions;
 	/**
 	 * Disallow unnecessary boolean casts
 	 */
-	noExtraBooleanCast?: RuleConfiguration;
+	noExtraBooleanCast?: RuleConfiguration_for_Null;
 	/**
 	 * Prefer for...of statement instead of Array.forEach.
 	 */
-	noForEach?: RuleConfiguration;
+	noForEach?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unclear usage of consecutive space characters in regular expression literals
 	 */
-	noMultipleSpacesInRegularExpressionLiterals?: RuleConfiguration;
+	noMultipleSpacesInRegularExpressionLiterals?: RuleConfiguration_for_Null;
 	/**
 	 * This rule reports when a class has no non-static members, such as for a class used exclusively as a static namespace.
 	 */
-	noStaticOnlyClass?: RuleConfiguration;
+	noStaticOnlyClass?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow this and super in static contexts.
 	 */
-	noThisInStatic?: RuleConfiguration;
+	noThisInStatic?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unnecessary catch clauses.
 	 */
-	noUselessCatch?: RuleConfiguration;
+	noUselessCatch?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unnecessary constructors.
 	 */
-	noUselessConstructor?: RuleConfiguration;
+	noUselessConstructor?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow empty exports that don't change anything in a module file.
 	 */
-	noUselessEmptyExport?: RuleConfiguration;
+	noUselessEmptyExport?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unnecessary fragments
 	 */
-	noUselessFragments?: RuleConfiguration;
+	noUselessFragments?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unnecessary labels.
 	 */
-	noUselessLabel?: RuleConfiguration;
+	noUselessLabel?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow unnecessary nested block statements.
+	 */
+	noUselessLoneBlockStatements?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow renaming import, export, and destructured assignments to the same name.
 	 */
-	noUselessRename?: RuleConfiguration;
+	noUselessRename?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow useless case in switch statements.
 	 */
-	noUselessSwitchCase?: RuleConfiguration;
+	noUselessSwitchCase?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow useless this aliasing.
 	 */
-	noUselessThisAlias?: RuleConfiguration;
+	noUselessThisAlias?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow using any or unknown as type constraint.
 	 */
-	noUselessTypeConstraint?: RuleConfiguration;
+	noUselessTypeConstraint?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of void operators, which is not a familiar operator.
 	 */
-	noVoid?: RuleConfiguration;
+	noVoid?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow with statements in non-strict contexts.
 	 */
-	noWith?: RuleConfiguration;
+	noWith?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
@@ -640,31 +653,31 @@ interface Complexity {
 	/**
 	 * Use arrow functions over function expressions.
 	 */
-	useArrowFunction?: RuleConfiguration;
+	useArrowFunction?: RuleConfiguration_for_Null;
 	/**
 	 * Promotes the use of .flatMap() when map().flat() are used together.
 	 */
-	useFlatMap?: RuleConfiguration;
+	useFlatMap?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce the usage of a literal access to properties over computed property access.
 	 */
-	useLiteralKeys?: RuleConfiguration;
+	useLiteralKeys?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce using concise optional chain instead of chained logical expressions.
 	 */
-	useOptionalChain?: RuleConfiguration;
+	useOptionalChain?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce the use of the regular expression literals instead of the RegExp constructor if possible.
 	 */
-	useRegexLiterals?: RuleConfiguration;
+	useRegexLiterals?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow number literal object member names which are not base10 or uses underscore as separator
 	 */
-	useSimpleNumberKeys?: RuleConfiguration;
+	useSimpleNumberKeys?: RuleConfiguration_for_Null;
 	/**
 	 * Discard redundant terms from logical expressions.
 	 */
-	useSimplifiedLogicExpression?: RuleConfiguration;
+	useSimplifiedLogicExpression?: RuleConfiguration_for_Null;
 }
 interface Correctness {
 	/**
@@ -674,115 +687,127 @@ interface Correctness {
 	/**
 	 * Prevent passing of children as props.
 	 */
-	noChildrenProp?: RuleConfiguration;
+	noChildrenProp?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents from having const variables being re-assigned.
 	 */
-	noConstAssign?: RuleConfiguration;
+	noConstAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow constant expressions in conditions
 	 */
-	noConstantCondition?: RuleConfiguration;
+	noConstantCondition?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow returning a value from a constructor.
 	 */
-	noConstructorReturn?: RuleConfiguration;
+	noConstructorReturn?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow empty character classes in regular expression literals.
 	 */
-	noEmptyCharacterClassInRegex?: RuleConfiguration;
+	noEmptyCharacterClassInRegex?: RuleConfiguration_for_Null;
 	/**
 	 * Disallows empty destructuring patterns.
 	 */
-	noEmptyPattern?: RuleConfiguration;
+	noEmptyPattern?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow calling global object properties as functions
 	 */
-	noGlobalObjectCalls?: RuleConfiguration;
+	noGlobalObjectCalls?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow function and var declarations that are accessible outside their block.
 	 */
-	noInnerDeclarations?: RuleConfiguration;
+	noInnerDeclarations?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents the incorrect use of super() inside classes. It also checks whether a call super() is missing from classes that extends other constructors.
 	 */
-	noInvalidConstructorSuper?: RuleConfiguration;
+	noInvalidConstructorSuper?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow new operators with global non-constructor functions.
 	 */
-	noInvalidNewBuiltin?: RuleConfiguration;
+	noInvalidNewBuiltin?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow the use of variables and function parameters before their declaration
+	 */
+	noInvalidUseBeforeDeclaration?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow new operators with the Symbol object.
 	 */
-	noNewSymbol?: RuleConfiguration;
+	noNewSymbol?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow \8 and \9 escape sequences in string literals.
 	 */
-	noNonoctalDecimalEscape?: RuleConfiguration;
+	noNonoctalDecimalEscape?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow literal numbers that lose precision
 	 */
-	noPrecisionLoss?: RuleConfiguration;
+	noPrecisionLoss?: RuleConfiguration_for_Null;
 	/**
 	 * Prevent the usage of the return value of React.render.
 	 */
-	noRenderReturnValue?: RuleConfiguration;
+	noRenderReturnValue?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow assignments where both sides are exactly the same.
 	 */
-	noSelfAssign?: RuleConfiguration;
+	noSelfAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow returning a value from a setter
 	 */
-	noSetterReturn?: RuleConfiguration;
+	noSetterReturn?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow comparison of expressions modifying the string case with non-compliant value.
 	 */
-	noStringCaseMismatch?: RuleConfiguration;
+	noStringCaseMismatch?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow lexical declarations in switch clauses.
 	 */
-	noSwitchDeclarations?: RuleConfiguration;
+	noSwitchDeclarations?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents the usage of variables that haven't been declared inside the document.
 	 */
-	noUndeclaredVariables?: RuleConfiguration;
+	noUndeclaredVariables?: RuleConfiguration_for_Null;
 	/**
 	 * Avoid using unnecessary continue.
 	 */
-	noUnnecessaryContinue?: RuleConfiguration;
+	noUnnecessaryContinue?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unreachable code
 	 */
-	noUnreachable?: RuleConfiguration;
+	noUnreachable?: RuleConfiguration_for_Null;
 	/**
 	 * Ensures the super() constructor is called exactly once on every code  path in a class constructor before this is accessed if the class has a superclass
 	 */
-	noUnreachableSuper?: RuleConfiguration;
+	noUnreachableSuper?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow control flow statements in finally blocks.
 	 */
-	noUnsafeFinally?: RuleConfiguration;
+	noUnsafeFinally?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of optional chaining in contexts where the undefined value is not allowed.
 	 */
-	noUnsafeOptionalChaining?: RuleConfiguration;
+	noUnsafeOptionalChaining?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow unused imports.
+	 */
+	noUnusedImports?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unused labels.
 	 */
-	noUnusedLabels?: RuleConfiguration;
+	noUnusedLabels?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow unused private class members
+	 */
+	noUnusedPrivateClassMembers?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unused variables.
 	 */
-	noUnusedVariables?: RuleConfiguration;
+	noUnusedVariables?: RuleConfiguration_for_Null;
 	/**
 	 * This rules prevents void elements (AKA self-closing elements) from having children.
 	 */
-	noVoidElementsWithChildren?: RuleConfiguration;
+	noVoidElementsWithChildren?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow returning a value from a function with the return type 'void'
 	 */
-	noVoidTypeReturn?: RuleConfiguration;
+	noVoidTypeReturn?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
@@ -790,23 +815,23 @@ interface Correctness {
 	/**
 	 * Enforce all dependencies are correctly specified in a React hook.
 	 */
-	useExhaustiveDependencies?: RuleConfiguration;
+	useExhaustiveDependencies?: RuleConfiguration_for_HooksOptions;
 	/**
 	 * Enforce that all React hooks are being called from the Top Level component functions.
 	 */
-	useHookAtTopLevel?: RuleConfiguration;
+	useHookAtTopLevel?: RuleConfiguration_for_DeprecatedHooksOptions;
 	/**
 	 * Require calls to isNaN() when checking for NaN.
 	 */
-	useIsNan?: RuleConfiguration;
+	useIsNan?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce "for" loop update clause moving the counter in the right direction.
 	 */
-	useValidForDirection?: RuleConfiguration;
+	useValidForDirection?: RuleConfiguration_for_Null;
 	/**
 	 * Require generator functions to contain yield.
 	 */
-	useYield?: RuleConfiguration;
+	useYield?: RuleConfiguration_for_Null;
 }
 interface Nursery {
 	/**
@@ -814,133 +839,85 @@ interface Nursery {
 	 */
 	all?: boolean;
 	/**
-	 * Disallow the use of console.
+	 * Disallow the use of barrel file.
 	 */
-	noConsole?: RuleConfiguration;
+	noBarrelFile?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow two keys with the same name inside a JSON object.
+	 * Disallow the use of console.
 	 */
-	noDuplicateJsonKeys?: RuleConfiguration;
+	noConsole?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow empty block statements and static blocks.
+	 * Disallow two keys with the same name inside a JSON object.
 	 */
-	noEmptyBlockStatements?: RuleConfiguration;
+	noDuplicateJsonKeys?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow empty type parameters in type aliases and interfaces.
+	 * A describe block should not contain duplicate hooks.
 	 */
-	noEmptyTypeParameters?: RuleConfiguration;
+	noDuplicateTestHooks?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow focused tests.
+	 * This rule enforces a maximum depth to nested describe() in test files.
 	 */
-	noFocusedTests?: RuleConfiguration;
+	noExcessiveNestedTestSuites?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow assignments to native objects and read-only global variables.
+	 * Disallow using export or module.exports in files containing tests
 	 */
-	noGlobalAssign?: RuleConfiguration;
+	noExportsInTest?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow the use of global eval().
+	 * Disallow focused tests.
 	 */
-	noGlobalEval?: RuleConfiguration;
+	noFocusedTests?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow the use of variables and function parameters before their declaration
+	 * Disallow the use of namespace imports.
 	 */
-	noInvalidUseBeforeDeclaration?: RuleConfiguration;
-	/**
-	 * Disallow characters made with multiple code points in character class syntax.
-	 */
-	noMisleadingCharacterClass?: RuleConfiguration;
+	noNamespaceImport?: RuleConfiguration_for_Null;
 	/**
 	 * Forbid the use of Node.js builtin modules.
 	 */
-	noNodejsModules?: RuleConfiguration;
+	noNodejsModules?: RuleConfiguration_for_Null;
 	/**
-	 * Avoid re-export all
+	 * Avoid re-export all.
 	 */
-	noReExportAll?: RuleConfiguration;
+	noReExportAll?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow specified modules when loaded by import or require.
 	 */
-	noRestrictedImports?: RuleConfiguration;
+	noRestrictedImports?: RuleConfiguration_for_RestrictedImportsOptions;
 	/**
-	 * Disallow disabled tests.
+	 * It detects possible "wrong" semicolons inside JSX elements.
 	 */
-	noSkippedTests?: RuleConfiguration;
+	noSemicolonInJsx?: RuleConfiguration_for_Null;
 	/**
-	 * Disallow then property.
+	 * Disallow disabled tests.
 	 */
-	noThenProperty?: RuleConfiguration;
+	noSkippedTests?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of dependencies that aren't specified in the package.json.
 	 */
-	noUndeclaredDependencies?: RuleConfiguration;
-	/**
-	 * Disallow unused imports.
-	 */
-	noUnusedImports?: RuleConfiguration;
-	/**
-	 * Disallow unused private class members
-	 */
-	noUnusedPrivateClassMembers?: RuleConfiguration;
-	/**
-	 * Disallow unnecessary nested block statements.
-	 */
-	noUselessLoneBlockStatements?: RuleConfiguration;
+	noUndeclaredDependencies?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow ternary operators when simpler alternatives exist.
 	 */
-	noUselessTernary?: RuleConfiguration;
+	noUselessTernary?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
 	recommended?: boolean;
-	/**
-	 * Ensure async functions utilize await.
-	 */
-	useAwait?: RuleConfiguration;
-	/**
-	 * Require consistently using either T[] or Array<T>
-	 */
-	useConsistentArrayType?: RuleConfiguration;
-	/**
-	 * Promotes the use of export type for types.
-	 */
-	useExportType?: RuleConfiguration;
-	/**
-	 * Enforce naming conventions for JavaScript and TypeScript filenames.
-	 */
-	useFilenamingConvention?: RuleConfiguration;
-	/**
-	 * This rule recommends a for-of loop when in a for loop, the index used to extract an item from the iterated array.
-	 */
-	useForOf?: RuleConfiguration;
-	/**
-	 * Enforce the use of import type when an import only has specifiers with type qualifier.
-	 */
-	useGroupedTypeImport?: RuleConfiguration;
 	/**
 	 * Disallows package private imports.
 	 */
-	useImportRestrictions?: RuleConfiguration;
+	useImportRestrictions?: RuleConfiguration_for_Null;
 	/**
-	 * Promotes the use of import type for types.
+	 * Disallow missing key props in iterators/collection literals.
 	 */
-	useImportType?: RuleConfiguration;
+	useJsxKeyInIterable?: RuleConfiguration_for_Null;
 	/**
-	 * Enforces using the node: protocol for Node.js builtin modules.
+	 * Promotes the usage of node:assert/strict over node:assert.
 	 */
-	useNodejsImportProtocol?: RuleConfiguration;
-	/**
-	 * Use the Number properties instead of global ones.
-	 */
-	useNumberNamespace?: RuleConfiguration;
-	/**
-	 * Enforce using function types instead of object type with call signatures.
-	 */
-	useShorthandFunctionType?: RuleConfiguration;
+	useNodeAssertStrict?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce the sorting of CSS utility classes.
 	 */
-	useSortedClasses?: RuleConfiguration;
+	useSortedClasses?: RuleConfiguration_for_UtilityClassSortingOptions;
 }
 interface Performance {
 	/**
@@ -950,11 +927,11 @@ interface Performance {
 	/**
 	 * Disallow the use of spread (...) syntax on accumulators.
 	 */
-	noAccumulatingSpread?: RuleConfiguration;
+	noAccumulatingSpread?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of the delete operator.
 	 */
-	noDelete?: RuleConfiguration;
+	noDelete?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
@@ -968,11 +945,15 @@ interface Security {
 	/**
 	 * Prevent the usage of dangerous JSX props
 	 */
-	noDangerouslySetInnerHtml?: RuleConfiguration;
+	noDangerouslySetInnerHtml?: RuleConfiguration_for_Null;
 	/**
 	 * Report when a DOM element or a component uses both children and dangerouslySetInnerHTML prop.
 	 */
-	noDangerouslySetInnerHtmlWithChildren?: RuleConfiguration;
+	noDangerouslySetInnerHtmlWithChildren?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow the use of global eval().
+	 */
+	noGlobalEval?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
@@ -986,63 +967,63 @@ interface Style {
 	/**
 	 * Disallow the use of arguments.
 	 */
-	noArguments?: RuleConfiguration;
+	noArguments?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow comma operator.
 	 */
-	noCommaOperator?: RuleConfiguration;
+	noCommaOperator?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow default exports.
 	 */
-	noDefaultExport?: RuleConfiguration;
+	noDefaultExport?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow implicit true values on JSX boolean attributes
 	 */
-	noImplicitBoolean?: RuleConfiguration;
+	noImplicitBoolean?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow type annotations for variables, parameters, and class properties initialized with a literal expression.
 	 */
-	noInferrableTypes?: RuleConfiguration;
+	noInferrableTypes?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of TypeScript's namespaces.
 	 */
-	noNamespace?: RuleConfiguration;
+	noNamespace?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow negation in the condition of an if statement if it has an else clause.
 	 */
-	noNegationElse?: RuleConfiguration;
+	noNegationElse?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow non-null assertions using the ! postfix operator.
 	 */
-	noNonNullAssertion?: RuleConfiguration;
+	noNonNullAssertion?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow reassigning function parameters.
 	 */
-	noParameterAssign?: RuleConfiguration;
+	noParameterAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of parameter properties in class constructors.
 	 */
-	noParameterProperties?: RuleConfiguration;
+	noParameterProperties?: RuleConfiguration_for_Null;
 	/**
 	 * This rule allows you to specify global variable names that you don’t want to use in your application.
 	 */
-	noRestrictedGlobals?: RuleConfiguration;
+	noRestrictedGlobals?: RuleConfiguration_for_RestrictedGlobalsOptions;
 	/**
 	 * Disallow the use of constants which its value is the upper-case version of its name.
 	 */
-	noShoutyConstants?: RuleConfiguration;
+	noShoutyConstants?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow template literals if interpolation and special-character handling are not needed
 	 */
-	noUnusedTemplateLiteral?: RuleConfiguration;
+	noUnusedTemplateLiteral?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow else block when the if block breaks early.
 	 */
-	noUselessElse?: RuleConfiguration;
+	noUselessElse?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of var
 	 */
-	noVar?: RuleConfiguration;
+	noVar?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
@@ -1050,75 +1031,107 @@ interface Style {
 	/**
 	 * Enforce the use of as const over literal type and type annotation.
 	 */
-	useAsConstAssertion?: RuleConfiguration;
+	useAsConstAssertion?: RuleConfiguration_for_Null;
 	/**
 	 * Requires following curly brace conventions.
 	 */
-	useBlockStatements?: RuleConfiguration;
+	useBlockStatements?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce using else if instead of nested if in else clauses.
 	 */
-	useCollapsedElseIf?: RuleConfiguration;
+	useCollapsedElseIf?: RuleConfiguration_for_Null;
+	/**
+	 * Require consistently using either T[] or Array<T>
+	 */
+	useConsistentArrayType?: RuleConfiguration_for_ConsistentArrayTypeOptions;
 	/**
 	 * Require const declarations for variables that are never reassigned after declared.
 	 */
-	useConst?: RuleConfiguration;
+	useConst?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce default function parameters and optional function parameters to be last.
 	 */
-	useDefaultParameterLast?: RuleConfiguration;
+	useDefaultParameterLast?: RuleConfiguration_for_Null;
 	/**
 	 * Require that each enum member value be explicitly initialized.
 	 */
-	useEnumInitializers?: RuleConfiguration;
+	useEnumInitializers?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of Math.pow in favor of the ** operator.
 	 */
-	useExponentiationOperator?: RuleConfiguration;
+	useExponentiationOperator?: RuleConfiguration_for_Null;
+	/**
+	 * Promotes the use of export type for types.
+	 */
+	useExportType?: RuleConfiguration_for_Null;
+	/**
+	 * Enforce naming conventions for JavaScript and TypeScript filenames.
+	 */
+	useFilenamingConvention?: RuleConfiguration_for_FilenamingConventionOptions;
+	/**
+	 * This rule recommends a for-of loop when in a for loop, the index used to extract an item from the iterated array.
+	 */
+	useForOf?: RuleConfiguration_for_Null;
 	/**
 	 * This rule enforces the use of <>...</> over <Fragment>...</Fragment>.
 	 */
-	useFragmentSyntax?: RuleConfiguration;
+	useFragmentSyntax?: RuleConfiguration_for_Null;
+	/**
+	 * Promotes the use of import type for types.
+	 */
+	useImportType?: RuleConfiguration_for_Null;
 	/**
 	 * Require all enum members to be literal values.
 	 */
-	useLiteralEnumMembers?: RuleConfiguration;
+	useLiteralEnumMembers?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce naming conventions for everything across a codebase.
 	 */
-	useNamingConvention?: RuleConfiguration;
+	useNamingConvention?: RuleConfiguration_for_NamingConventionOptions;
+	/**
+	 * Enforces using the node: protocol for Node.js builtin modules.
+	 */
+	useNodejsImportProtocol?: RuleConfiguration_for_Null;
+	/**
+	 * Use the Number properties instead of global ones.
+	 */
+	useNumberNamespace?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals
 	 */
-	useNumericLiterals?: RuleConfiguration;
+	useNumericLiterals?: RuleConfiguration_for_Null;
 	/**
 	 * Prevent extra closing tags for components without children
 	 */
-	useSelfClosingElements?: RuleConfiguration;
+	useSelfClosingElements?: RuleConfiguration_for_Null;
 	/**
 	 * When expressing array types, this rule promotes the usage of T[] shorthand instead of Array<T>.
 	 */
-	useShorthandArrayType?: RuleConfiguration;
+	useShorthandArrayType?: RuleConfiguration_for_Null;
 	/**
 	 * Require assignment operator shorthand where possible.
 	 */
-	useShorthandAssign?: RuleConfiguration;
+	useShorthandAssign?: RuleConfiguration_for_Null;
+	/**
+	 * Enforce using function types instead of object type with call signatures.
+	 */
+	useShorthandFunctionType?: RuleConfiguration_for_Null;
 	/**
 	 * Enforces switch clauses have a single statement, emits a quick fix wrapping the statements in a block.
 	 */
-	useSingleCaseStatement?: RuleConfiguration;
+	useSingleCaseStatement?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow multiple variable declarations in the same variable statement
 	 */
-	useSingleVarDeclarator?: RuleConfiguration;
+	useSingleVarDeclarator?: RuleConfiguration_for_Null;
 	/**
 	 * Prefer template literals over string concatenation.
 	 */
-	useTemplate?: RuleConfiguration;
+	useTemplate?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce the use of while loops instead of for loops when the initializer and update expressions are not needed.
 	 */
-	useWhile?: RuleConfiguration;
+	useWhile?: RuleConfiguration_for_Null;
 }
 interface Suspicious {
 	/**
@@ -1128,187 +1141,207 @@ interface Suspicious {
 	/**
 	 * Use standard constants instead of approximated literals.
 	 */
-	noApproximativeNumericConstant?: RuleConfiguration;
+	noApproximativeNumericConstant?: RuleConfiguration_for_Null;
 	/**
 	 * Discourage the usage of Array index in keys.
 	 */
-	noArrayIndexKey?: RuleConfiguration;
+	noArrayIndexKey?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow assignments in expressions.
 	 */
-	noAssignInExpressions?: RuleConfiguration;
+	noAssignInExpressions?: RuleConfiguration_for_Null;
 	/**
 	 * Disallows using an async function as a Promise executor.
 	 */
-	noAsyncPromiseExecutor?: RuleConfiguration;
+	noAsyncPromiseExecutor?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow reassigning exceptions in catch clauses.
 	 */
-	noCatchAssign?: RuleConfiguration;
+	noCatchAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow reassigning class members.
 	 */
-	noClassAssign?: RuleConfiguration;
+	noClassAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Prevent comments from being inserted as text nodes
 	 */
-	noCommentText?: RuleConfiguration;
+	noCommentText?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow comparing against -0
 	 */
-	noCompareNegZero?: RuleConfiguration;
+	noCompareNegZero?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow labeled statements that are not loops.
 	 */
-	noConfusingLabels?: RuleConfiguration;
+	noConfusingLabels?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow void type outside of generic or return types.
 	 */
-	noConfusingVoidType?: RuleConfiguration;
+	noConfusingVoidType?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of console.log
 	 */
-	noConsoleLog?: RuleConfiguration;
+	noConsoleLog?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow TypeScript const enum
 	 */
-	noConstEnum?: RuleConfiguration;
+	noConstEnum?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents from having control characters and some escape sequences that match control characters in regular expressions.
 	 */
-	noControlCharactersInRegex?: RuleConfiguration;
+	noControlCharactersInRegex?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the use of debugger
 	 */
-	noDebugger?: RuleConfiguration;
+	noDebugger?: RuleConfiguration_for_Null;
 	/**
 	 * Require the use of === and !==
 	 */
-	noDoubleEquals?: RuleConfiguration;
+	noDoubleEquals?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow duplicate case labels.
 	 */
-	noDuplicateCase?: RuleConfiguration;
+	noDuplicateCase?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow duplicate class members.
 	 */
-	noDuplicateClassMembers?: RuleConfiguration;
+	noDuplicateClassMembers?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents JSX properties to be assigned multiple times.
 	 */
-	noDuplicateJsxProps?: RuleConfiguration;
+	noDuplicateJsxProps?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents object literals having more than one property declaration for the same name.
 	 */
-	noDuplicateObjectKeys?: RuleConfiguration;
+	noDuplicateObjectKeys?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow duplicate function parameter name.
 	 */
-	noDuplicateParameters?: RuleConfiguration;
+	noDuplicateParameters?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow empty block statements and static blocks.
+	 */
+	noEmptyBlockStatements?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the declaration of empty interfaces.
 	 */
-	noEmptyInterface?: RuleConfiguration;
+	noEmptyInterface?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow the any type usage.
 	 */
-	noExplicitAny?: RuleConfiguration;
+	noExplicitAny?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents the wrong usage of the non-null assertion operator (!) in TypeScript files.
 	 */
-	noExtraNonNullAssertion?: RuleConfiguration;
+	noExtraNonNullAssertion?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow fallthrough of switch clauses.
 	 */
-	noFallthroughSwitchClause?: RuleConfiguration;
+	noFallthroughSwitchClause?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow reassigning function declarations.
 	 */
-	noFunctionAssign?: RuleConfiguration;
+	noFunctionAssign?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow assignments to native objects and read-only global variables.
+	 */
+	noGlobalAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Use Number.isFinite instead of global isFinite.
 	 */
-	noGlobalIsFinite?: RuleConfiguration;
+	noGlobalIsFinite?: RuleConfiguration_for_Null;
 	/**
 	 * Use Number.isNaN instead of global isNaN.
 	 */
-	noGlobalIsNan?: RuleConfiguration;
+	noGlobalIsNan?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow use of implicit any type on variable declarations.
 	 */
-	noImplicitAnyLet?: RuleConfiguration;
+	noImplicitAnyLet?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow assigning to imported bindings
 	 */
-	noImportAssign?: RuleConfiguration;
+	noImportAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow labels that share a name with a variable
 	 */
-	noLabelVar?: RuleConfiguration;
+	noLabelVar?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow characters made with multiple code points in character class syntax.
+	 */
+	noMisleadingCharacterClass?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce proper usage of new and constructor.
 	 */
-	noMisleadingInstantiator?: RuleConfiguration;
+	noMisleadingInstantiator?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow shorthand assign when variable appears on both sides.
 	 */
-	noMisrefactoredShorthandAssign?: RuleConfiguration;
+	noMisrefactoredShorthandAssign?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow direct use of Object.prototype builtins.
 	 */
-	noPrototypeBuiltins?: RuleConfiguration;
+	noPrototypeBuiltins?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow variable, function, class, and type redeclarations in the same scope.
 	 */
-	noRedeclare?: RuleConfiguration;
+	noRedeclare?: RuleConfiguration_for_Null;
 	/**
 	 * Prevents from having redundant "use strict".
 	 */
-	noRedundantUseStrict?: RuleConfiguration;
+	noRedundantUseStrict?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow comparisons where both sides are exactly the same.
 	 */
-	noSelfCompare?: RuleConfiguration;
+	noSelfCompare?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow identifiers from shadowing restricted names.
 	 */
-	noShadowRestrictedNames?: RuleConfiguration;
+	noShadowRestrictedNames?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow sparse arrays
 	 */
-	noSparseArray?: RuleConfiguration;
+	noSparseArray?: RuleConfiguration_for_Null;
+	/**
+	 * Disallow then property.
+	 */
+	noThenProperty?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow unsafe declaration merging between interfaces and classes.
 	 */
-	noUnsafeDeclarationMerging?: RuleConfiguration;
+	noUnsafeDeclarationMerging?: RuleConfiguration_for_Null;
 	/**
 	 * Disallow using unsafe negation.
 	 */
-	noUnsafeNegation?: RuleConfiguration;
+	noUnsafeNegation?: RuleConfiguration_for_Null;
 	/**
 	 * It enables the recommended rules for this group
 	 */
 	recommended?: boolean;
+	/**
+	 * Ensure async functions utilize await.
+	 */
+	useAwait?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce default clauses in switch statements to be last
 	 */
-	useDefaultSwitchClauseLast?: RuleConfiguration;
+	useDefaultSwitchClauseLast?: RuleConfiguration_for_Null;
 	/**
 	 * Enforce get methods to always return a value.
 	 */
-	useGetterReturn?: RuleConfiguration;
+	useGetterReturn?: RuleConfiguration_for_Null;
 	/**
 	 * Use Array.isArray() instead of instanceof Array.
 	 */
-	useIsArray?: RuleConfiguration;
+	useIsArray?: RuleConfiguration_for_Null;
 	/**
 	 * Require using the namespace keyword over the module keyword to declare TypeScript namespaces.
 	 */
-	useNamespaceKeyword?: RuleConfiguration;
+	useNamespaceKeyword?: RuleConfiguration_for_Null;
 	/**
 	 * 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
 	 */
-	useValidTypeof?: RuleConfiguration;
+	useValidTypeof?: RuleConfiguration_for_Null;
 }
 interface OverrideFormatterConfiguration {
 	/**
@@ -1357,58 +1390,116 @@ interface OverrideOrganizeImportsConfiguration {
 	 */
 	enabled?: boolean;
 }
-type RuleConfiguration = RulePlainConfiguration | RuleWithOptions;
+type RuleConfiguration_for_Null =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_Null;
+type RuleConfiguration_for_ValidAriaRoleOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_ValidAriaRoleOptions;
+type RuleConfiguration_for_ComplexityOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_ComplexityOptions;
+type RuleConfiguration_for_HooksOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_HooksOptions;
+type RuleConfiguration_for_DeprecatedHooksOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_DeprecatedHooksOptions;
+type RuleConfiguration_for_RestrictedImportsOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_RestrictedImportsOptions;
+type RuleConfiguration_for_UtilityClassSortingOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_UtilityClassSortingOptions;
+type RuleConfiguration_for_RestrictedGlobalsOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_RestrictedGlobalsOptions;
+type RuleConfiguration_for_ConsistentArrayTypeOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_ConsistentArrayTypeOptions;
+type RuleConfiguration_for_FilenamingConventionOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_FilenamingConventionOptions;
+type RuleConfiguration_for_NamingConventionOptions =
+	| RulePlainConfiguration
+	| RuleWithOptions_for_NamingConventionOptions;
 type RulePlainConfiguration = "warn" | "error" | "off";
-interface RuleWithOptions {
+interface RuleWithOptions_for_Null {
+	level: RulePlainConfiguration;
+	options: null;
+}
+interface RuleWithOptions_for_ValidAriaRoleOptions {
+	level: RulePlainConfiguration;
+	options: ValidAriaRoleOptions;
+}
+interface RuleWithOptions_for_ComplexityOptions {
 	level: RulePlainConfiguration;
-	options?: PossibleOptions;
-}
-type PossibleOptions =
-	| ComplexityOptions
-	| ConsistentArrayTypeOptions
-	| FilenamingConventionOptions
-	| HooksOptions
-	| DeprecatedHooksOptions
-	| NamingConventionOptions
-	| RestrictedGlobalsOptions
-	| RestrictedImportsOptions
-	| ValidAriaRoleOptions
-	| UtilityClassSortingOptions;
+	options: ComplexityOptions;
+}
+interface RuleWithOptions_for_HooksOptions {
+	level: RulePlainConfiguration;
+	options: HooksOptions;
+}
+interface RuleWithOptions_for_DeprecatedHooksOptions {
+	level: RulePlainConfiguration;
+	options: DeprecatedHooksOptions;
+}
+interface RuleWithOptions_for_RestrictedImportsOptions {
+	level: RulePlainConfiguration;
+	options: RestrictedImportsOptions;
+}
+interface RuleWithOptions_for_UtilityClassSortingOptions {
+	level: RulePlainConfiguration;
+	options: UtilityClassSortingOptions;
+}
+interface RuleWithOptions_for_RestrictedGlobalsOptions {
+	level: RulePlainConfiguration;
+	options: RestrictedGlobalsOptions;
+}
+interface RuleWithOptions_for_ConsistentArrayTypeOptions {
+	level: RulePlainConfiguration;
+	options: ConsistentArrayTypeOptions;
+}
+interface RuleWithOptions_for_FilenamingConventionOptions {
+	level: RulePlainConfiguration;
+	options: FilenamingConventionOptions;
+}
+interface RuleWithOptions_for_NamingConventionOptions {
+	level: RulePlainConfiguration;
+	options: NamingConventionOptions;
+}
+interface ValidAriaRoleOptions {
+	allowInvalidRoles: string[];
+	ignoreNonDom: boolean;
+}
 interface ComplexityOptions {
 	/**
 	 * The maximum complexity score that we allow. Anything higher is considered excessive.
 	 */
 	maxAllowedComplexity: number;
 }
-interface ConsistentArrayTypeOptions {
-	syntax: ConsistentArrayType;
-}
-interface FilenamingConventionOptions {
-	/**
-	 * Allowed cases for _TypeScript_ `enum` member names.
-	 */
-	filenameCases: FilenameCases;
+interface HooksOptions {
 	/**
-	 * If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].
+	 * List of hooks of which the dependencies should be validated.
 	 */
-	strictCase: boolean;
+	hooks: Hook[];
 }
-interface HooksOptions {
+interface DeprecatedHooksOptions {}
+interface RestrictedImportsOptions {
 	/**
-	 * List of safe hooks
+	 * A list of names that should trigger the rule
 	 */
-	hooks: Hooks[];
+	paths: {};
 }
-interface DeprecatedHooksOptions {}
-interface NamingConventionOptions {
+interface UtilityClassSortingOptions {
 	/**
-	 * Allowed cases for _TypeScript_ `enum` member names.
+	 * Additional attributes that will be sorted.
 	 */
-	enumMemberCase: EnumMemberCase;
+	attributes?: string[];
 	/**
-	 * If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].
+	 * Names of the functions or tagged templates that will be sorted.
 	 */
-	strictCase: boolean;
+	functions?: string[];
 }
 interface RestrictedGlobalsOptions {
 	/**
@@ -1416,45 +1507,67 @@ interface RestrictedGlobalsOptions {
 	 */
 	deniedGlobals: string[];
 }
-interface RestrictedImportsOptions {
+interface ConsistentArrayTypeOptions {
+	syntax: ConsistentArrayType;
+}
+interface FilenamingConventionOptions {
 	/**
-	 * A list of names that should trigger the rule
+	 * Allowed cases for _TypeScript_ `enum` member names.
 	 */
-	paths: {};
-}
-interface ValidAriaRoleOptions {
-	allowInvalidRoles: string[];
-	ignoreNonDom: boolean;
+	filenameCases: FilenameCases;
+	/**
+	 * If `false`, then non-ASCII characters are allowed.
+	 */
+	requireAscii: boolean;
+	/**
+	 * If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].
+	 */
+	strictCase: boolean;
 }
-interface UtilityClassSortingOptions {
+interface NamingConventionOptions {
 	/**
-	 * Additional attributes that will be sorted.
+	 * Allowed cases for _TypeScript_ `enum` member names.
 	 */
-	attributes?: string[];
+	enumMemberCase: EnumMemberCase;
 	/**
-	 * Names of the functions or tagged templates that will be sorted.
+	 * If `false`, then non-ASCII characters are allowed.
 	 */
-	functions?: string[];
+	requireAscii: boolean;
+	/**
+	 * If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].
+	 */
+	strictCase: boolean;
 }
-type ConsistentArrayType = "shorthand" | "generic";
-type FilenameCases = FilenameCase[];
-interface Hooks {
+interface Hook {
 	/**
 	* The "position" of the closure function, starting from zero.
 
-### Example 
+For example, for React's `useEffect()` hook, the closure index is 0. 
 	 */
 	closureIndex?: number;
 	/**
-	 * The "position" of the array of dependencies, starting from zero.
+	* The "position" of the array of dependencies, starting from zero.
+
+For example, for React's `useEffect()` hook, the dependencies index is 1. 
 	 */
 	dependenciesIndex?: number;
 	/**
-	 * The name of the hook
+	 * The name of the hook.
 	 */
 	name: string;
+	/**
+	* Whether the result of the hook is stable.
+
+Set to `true` to mark the identity of the hook's return value as stable, or use a number/an array of numbers to mark the "positions" in the return array as stable.
+
+For example, for React's `useRef()` hook the value would be `true`, while for `useState()` it would be `[1]`. 
+	 */
+	stableResult: StableHookResult;
 }
+type ConsistentArrayType = "shorthand" | "generic";
+type FilenameCases = FilenameCase[];
 type EnumMemberCase = "PascalCase" | "CONSTANT_CASE" | "camelCase";
+type StableHookResult = "None" | "Identity" | { Indices: number[] };
 type FilenameCase =
 	| "camelCase"
 	| "export"
@@ -1462,66 +1575,84 @@ type FilenameCase =
 	| "PascalCase"
 	| "snake_case";
 interface UpdateProjectParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface OpenProjectParams {
 	content: string;
-	path: RomePath;
+	path: BiomePath;
 	version: number;
 }
 interface OpenFileParams {
 	content: string;
-	language_hint?: Language;
-	path: RomePath;
+	document_file_source?: DocumentFileSource;
+	path: BiomePath;
 	version: number;
 }
-type Language =
-	| "Astro"
-	| "Vue"
-	| "JavaScript"
-	| "JavaScriptReact"
-	| "TypeScript"
-	| "TypeScriptReact"
-	| "Json"
-	| "Jsonc"
-	| "Css"
-	| "Unknown";
+type DocumentFileSource =
+	| "Unknown"
+	| { Js: JsFileSource }
+	| { Json: JsonFileSource }
+	| { Css: CssFileSource };
+interface JsFileSource {
+	/**
+	 * Used to mark if the source is being used for an Astro, Svelte or Vue file
+	 */
+	embedding_kind: EmbeddingKind;
+	language: Language;
+	module_kind: ModuleKind;
+	variant: LanguageVariant;
+	version: LanguageVersion;
+}
+interface JsonFileSource {
+	allow_trailing_comma: boolean;
+	variant: JsonVariant;
+}
+interface CssFileSource {
+	variant: CssVariant;
+}
+type EmbeddingKind = "Astro" | "Vue" | "Svelte" | "None";
+type Language = "JavaScript" | { TypeScript: { definition_file: boolean } };
+type ModuleKind = "Script" | "Module";
+type LanguageVariant = "Standard" | "StandardRestricted" | "Jsx";
+type LanguageVersion = "ES2022" | "ESNext";
+type JsonVariant = "Standard" | "Jsonc";
+type CssVariant = "Standard";
 interface ChangeFileParams {
 	content: string;
-	path: RomePath;
+	path: BiomePath;
 	version: number;
 }
 interface CloseFileParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface GetSyntaxTreeParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface GetSyntaxTreeResult {
 	ast: string;
 	cst: string;
 }
 interface OrganizeImportsParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface OrganizeImportsResult {
 	code: string;
 }
 interface GetFileContentParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface GetControlFlowGraphParams {
 	cursor: TextSize;
-	path: RomePath;
+	path: BiomePath;
 }
 type TextSize = number;
 interface GetFormatterIRParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface PullDiagnosticsParams {
 	categories: RuleCategories;
 	max_diagnostics: number;
-	path: RomePath;
+	path: BiomePath;
 }
 type RuleCategories = RuleCategory[];
 type RuleCategory = "Syntax" | "Lint" | "Action" | "Transformation";
@@ -1576,6 +1707,7 @@ type Category =
 	| "lint/a11y/useValidAriaValues"
 	| "lint/a11y/useValidLang"
 	| "lint/complexity/noBannedTypes"
+	| "lint/complexity/noEmptyTypeParameters"
 	| "lint/complexity/noExcessiveCognitiveComplexity"
 	| "lint/complexity/noExtraBooleanCast"
 	| "lint/complexity/noForEach"
@@ -1587,6 +1719,7 @@ type Category =
 	| "lint/complexity/noUselessEmptyExport"
 	| "lint/complexity/noUselessFragments"
 	| "lint/complexity/noUselessLabel"
+	| "lint/complexity/noUselessLoneBlockStatements"
 	| "lint/complexity/noUselessRename"
 	| "lint/complexity/noUselessSwitchCase"
 	| "lint/complexity/noUselessThisAlias"
@@ -1610,6 +1743,7 @@ type Category =
 	| "lint/correctness/noInnerDeclarations"
 	| "lint/correctness/noInvalidConstructorSuper"
 	| "lint/correctness/noInvalidNewBuiltin"
+	| "lint/correctness/noInvalidUseBeforeDeclaration"
 	| "lint/correctness/noNewSymbol"
 	| "lint/correctness/noNonoctalDecimalEscape"
 	| "lint/correctness/noPrecisionLoss"
@@ -1624,7 +1758,9 @@ type Category =
 	| "lint/correctness/noUnreachableSuper"
 	| "lint/correctness/noUnsafeFinally"
 	| "lint/correctness/noUnsafeOptionalChaining"
+	| "lint/correctness/noUnusedImports"
 	| "lint/correctness/noUnusedLabels"
+	| "lint/correctness/noUnusedPrivateClassMembers"
 	| "lint/correctness/noUnusedVariables"
 	| "lint/correctness/noVoidElementsWithChildren"
 	| "lint/correctness/noVoidTypeReturn"
@@ -1634,43 +1770,32 @@ type Category =
 	| "lint/correctness/useValidForDirection"
 	| "lint/correctness/useYield"
 	| "lint/nursery/noApproximativeNumericConstant"
+	| "lint/nursery/noBarrelFile"
 	| "lint/nursery/noConsole"
 	| "lint/nursery/noDuplicateJsonKeys"
-	| "lint/nursery/noEmptyBlockStatements"
-	| "lint/nursery/noEmptyTypeParameters"
+	| "lint/nursery/noDuplicateTestHooks"
+	| "lint/nursery/noExcessiveNestedTestSuites"
+	| "lint/nursery/noExportsInTest"
 	| "lint/nursery/noFocusedTests"
-	| "lint/nursery/noGlobalAssign"
-	| "lint/nursery/noGlobalEval"
-	| "lint/nursery/noInvalidUseBeforeDeclaration"
-	| "lint/nursery/noMisleadingCharacterClass"
+	| "lint/nursery/noNamespaceImport"
 	| "lint/nursery/noNodejsModules"
 	| "lint/nursery/noReExportAll"
 	| "lint/nursery/noRestrictedImports"
+	| "lint/nursery/noSemicolonInJsx"
 	| "lint/nursery/noSkippedTests"
-	| "lint/nursery/noThenProperty"
 	| "lint/nursery/noTypeOnlyImportAttributes"
 	| "lint/nursery/noUndeclaredDependencies"
-	| "lint/nursery/noUnusedImports"
-	| "lint/nursery/noUnusedPrivateClassMembers"
-	| "lint/nursery/noUselessLoneBlockStatements"
 	| "lint/nursery/noUselessTernary"
-	| "lint/nursery/useAwait"
 	| "lint/nursery/useBiomeSuppressionComment"
-	| "lint/nursery/useConsistentArrayType"
-	| "lint/nursery/useExportType"
-	| "lint/nursery/useFilenamingConvention"
-	| "lint/nursery/useForOf"
-	| "lint/nursery/useGroupedTypeImport"
 	| "lint/nursery/useImportRestrictions"
-	| "lint/nursery/useImportType"
-	| "lint/nursery/useNodejsImportProtocol"
-	| "lint/nursery/useNumberNamespace"
-	| "lint/nursery/useShorthandFunctionType"
+	| "lint/nursery/useJsxKeyInIterable"
+	| "lint/nursery/useNodeAssertStrict"
 	| "lint/nursery/useSortedClasses"
 	| "lint/performance/noAccumulatingSpread"
 	| "lint/performance/noDelete"
 	| "lint/security/noDangerouslySetInnerHtml"
 	| "lint/security/noDangerouslySetInnerHtmlWithChildren"
+	| "lint/security/noGlobalEval"
 	| "lint/style/noArguments"
 	| "lint/style/noCommaOperator"
 	| "lint/style/noDefaultExport"
@@ -1689,17 +1814,25 @@ type Category =
 	| "lint/style/useAsConstAssertion"
 	| "lint/style/useBlockStatements"
 	| "lint/style/useCollapsedElseIf"
+	| "lint/style/useConsistentArrayType"
 	| "lint/style/useConst"
 	| "lint/style/useDefaultParameterLast"
 	| "lint/style/useEnumInitializers"
 	| "lint/style/useExponentiationOperator"
+	| "lint/style/useExportType"
+	| "lint/style/useFilenamingConvention"
+	| "lint/style/useForOf"
 	| "lint/style/useFragmentSyntax"
+	| "lint/style/useImportType"
 	| "lint/style/useLiteralEnumMembers"
 	| "lint/style/useNamingConvention"
+	| "lint/style/useNodejsImportProtocol"
+	| "lint/style/useNumberNamespace"
 	| "lint/style/useNumericLiterals"
 	| "lint/style/useSelfClosingElements"
 	| "lint/style/useShorthandArrayType"
 	| "lint/style/useShorthandAssign"
+	| "lint/style/useShorthandFunctionType"
 	| "lint/style/useSingleCaseStatement"
 	| "lint/style/useSingleVarDeclarator"
 	| "lint/style/useTemplate"
@@ -1724,16 +1857,19 @@ type Category =
 	| "lint/suspicious/noDuplicateJsxProps"
 	| "lint/suspicious/noDuplicateObjectKeys"
 	| "lint/suspicious/noDuplicateParameters"
+	| "lint/suspicious/noEmptyBlockStatements"
 	| "lint/suspicious/noEmptyInterface"
 	| "lint/suspicious/noExplicitAny"
 	| "lint/suspicious/noExtraNonNullAssertion"
 	| "lint/suspicious/noFallthroughSwitchClause"
 	| "lint/suspicious/noFunctionAssign"
+	| "lint/suspicious/noGlobalAssign"
 	| "lint/suspicious/noGlobalIsFinite"
 	| "lint/suspicious/noGlobalIsNan"
 	| "lint/suspicious/noImplicitAnyLet"
 	| "lint/suspicious/noImportAssign"
 	| "lint/suspicious/noLabelVar"
+	| "lint/suspicious/noMisleadingCharacterClass"
 	| "lint/suspicious/noMisleadingInstantiator"
 	| "lint/suspicious/noMisrefactoredShorthandAssign"
 	| "lint/suspicious/noPrototypeBuiltins"
@@ -1742,8 +1878,10 @@ type Category =
 	| "lint/suspicious/noSelfCompare"
 	| "lint/suspicious/noShadowRestrictedNames"
 	| "lint/suspicious/noSparseArray"
+	| "lint/suspicious/noThenProperty"
 	| "lint/suspicious/noUnsafeDeclarationMerging"
 	| "lint/suspicious/noUnsafeNegation"
+	| "lint/suspicious/useAwait"
 	| "lint/suspicious/useDefaultSwitchClauseLast"
 	| "lint/suspicious/useGetterReturn"
 	| "lint/suspicious/useIsArray"
@@ -1845,7 +1983,7 @@ interface BacktraceSymbol {
 	name?: string;
 }
 interface PullActionsParams {
-	path: RomePath;
+	path: BiomePath;
 	range: TextRange;
 }
 interface PullActionsResult {
@@ -1881,7 +2019,7 @@ type SourceActionKind =
 	| { Other: string };
 type Applicability = "Always" | "MaybeIncorrect";
 interface FormatFileParams {
-	path: RomePath;
+	path: BiomePath;
 }
 interface Printed {
 	code: string;
@@ -1900,16 +2038,16 @@ interface SourceMarker {
 	source: TextSize;
 }
 interface FormatRangeParams {
-	path: RomePath;
+	path: BiomePath;
 	range: TextRange;
 }
 interface FormatOnTypeParams {
 	offset: TextSize;
-	path: RomePath;
+	path: BiomePath;
 }
 interface FixFileParams {
 	fix_file_mode: FixFileMode;
-	path: RomePath;
+	path: BiomePath;
 	should_format: boolean;
 }
 type FixFileMode = "SafeFixes" | "SafeAndUnsafeFixes";
@@ -1943,7 +2081,7 @@ interface FixAction {
 }
 interface RenameParams {
 	new_name: string;
-	path: RomePath;
+	path: BiomePath;
 	symbol_at: TextSize;
 }
 interface RenameResult {