@flint.fyi/ts 0.19.1 → 0.21.0

package/lib/plugin.d.ts

@@ -1,226 +1,222 @@
-import * as _flint_fyi_core0 from "@flint.fyi/core";
-import * as zod_v40 from "zod/v4";
-import * as zod_v4_core0 from "zod/v4/core";
-
 //#region src/plugin.d.ts
-declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "javascript" | "all" | "typescript", [_flint_fyi_core0.Rule<{
+declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout<string>, "javascript" | "all" | "typescript", [import("@flint.fyi/core").Rule<{
   readonly description: "Reports getter and setter accessors for the same property that are not adjacent.";
   readonly id: "accessorPairGroups";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "notGrouped", undefined>, _flint_fyi_core0.Rule<{
+}, "notGrouped", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports mismatched types between getter and setter accessor pairs.";
   readonly id: "accessorPairTypes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "mismatchedTypes", undefined>, _flint_fyi_core0.Rule<{
+}, "mismatchedTypes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports recursive access to this within getters and setters.";
   readonly id: "accessorThisRecursion";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noGetterRecursion" | "noSetterRecursion", undefined>, _flint_fyi_core0.Rule<{
+}, "noGetterRecursion" | "noSetterRecursion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports calling a function with a value typed as `any` as an argument.";
   readonly id: "anyArguments";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unsafeArgument" | "unsafeSpread" | "unsafeTupleSpread", undefined>, _flint_fyi_core0.Rule<{
+}, "unsafeArgument" | "unsafeSpread" | "unsafeTupleSpread", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports assigning a value with type `any` to variables and properties.";
   readonly id: "anyAssignments";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unsafeArrayDestructure" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeAssignmentToVariable" | "unsafeObjectPattern", undefined>, _flint_fyi_core0.Rule<{
+}, "unsafeArrayDestructure" | "unsafeArrayPatternFromTuple" | "unsafeArraySpread" | "unsafeAssignment" | "unsafeAssignmentToVariable" | "unsafeObjectPattern", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports calling a value with type `any`.";
   readonly id: "anyCalls";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unsafeCall" | "unsafeNew" | "unsafeTemplateTag", undefined>, _flint_fyi_core0.Rule<{
+}, "unsafeCall" | "unsafeNew" | "unsafeTemplateTag", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports member access on a value with type `any`.";
   readonly id: "anyMemberAccess";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unsafeComputedMemberAccess" | "unsafeMemberAccess", undefined>, _flint_fyi_core0.Rule<{
+}, "unsafeComputedMemberAccess" | "unsafeMemberAccess", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports returning a value with type `any` from a function.";
   readonly id: "anyReturns";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>, _flint_fyi_core0.Rule<{
+}, "unsafeReturn" | "unsafeReturnAssignment" | "unsafeReturnThis", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the arguments object instead of rest parameters.";
   readonly id: "arguments";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferRestParameters", undefined>, _flint_fyi_core0.Rule<{
+}, "preferRestParameters", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports missing return statements in callbacks of array methods.";
   readonly id: "arrayCallbackReturns";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingReturn", undefined>, _flint_fyi_core0.Rule<{
+}, "missingReturn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the `Array` constructor to create arrays instead of array literal syntax.";
   readonly id: "arrayConstructors";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.";
   readonly id: "arrayDeleteUnnecessaryCounts";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryCount", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryCount", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the `delete` operator on array values.";
   readonly id: "arrayElementDeletions";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noArrayDelete", undefined>, _flint_fyi_core0.Rule<{
+}, "noArrayDelete", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports array methods with callbacks that will never be invoked on arrays with empty slots.";
   readonly id: "arrayEmptyCallbackSlots";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "neverInvoked", undefined>, _flint_fyi_core0.Rule<{
+}, "neverInvoked", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports inconsistent styles for checking element existence using index methods.";
   readonly id: "arrayExistenceChecksConsistency";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferEqualsMinusOne" | "preferNotEqualsMinusOne", undefined>, _flint_fyi_core0.Rule<{
+}, "preferEqualsMinusOne" | "preferNotEqualsMinusOne", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.filter()` when only the first or last matching element is needed.";
   readonly id: "arrayFilteredFinds";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferFind" | "preferFindLast", undefined>, _flint_fyi_core0.Rule<{
+}, "preferFind" | "preferFindLast", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.filter()[0]` instead of `.find()` when looking for a single element.";
   readonly id: "arrayFinds";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferFind", undefined>, _flint_fyi_core0.Rule<{
+}, "preferFind", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.map().flat()` when `.flatMap()` can be used.";
   readonly id: "arrayFlatMapMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferFlatMap", undefined>, _flint_fyi_core0.Rule<{
+}, "preferFlatMap", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports legacy techniques to flatten arrays instead of using `.flat()`.";
   readonly id: "arrayFlatMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferFlat", undefined>, _flint_fyi_core0.Rule<{
+}, "preferFlat", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `1` as the depth argument of `.flat()` since it is the default.";
   readonly id: "arrayFlatUnnecessaryDepths";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryDepth", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryDepth", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.indexOf()` comparisons that can be replaced with `.includes()`.";
   readonly id: "arrayIncludes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferIncludes", undefined>, _flint_fyi_core0.Rule<{
+}, "preferIncludes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `Array#some()` with simple equality checks that can be replaced with `.includes()`.";
   readonly id: "arrayIncludesMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferIncludes", undefined>, _flint_fyi_core0.Rule<{
+}, "preferIncludes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.findIndex()` or `.findLastIndex()` with simple equality checks that can be replaced with `.indexOf()` or `.lastIndexOf()`.";
   readonly id: "arrayIndexOfMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferIndexOf" | "preferLastIndexOf", undefined>, _flint_fyi_core0.Rule<{
+}, "preferIndexOf" | "preferLastIndexOf", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.forEach()` when a for-of loop can be used.";
   readonly id: "arrayLoops";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferForOf", undefined>, _flint_fyi_core0.Rule<{
+}, "preferForOf", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.flatMap()` with an identity function that returns its argument unchanged.";
   readonly id: "arrayMapIdentities";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "identityFlatMap", undefined>, _flint_fyi_core0.Rule<{
+}, "identityFlatMap", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports `.reverse()` calls on arrays that mutate the original array.";
   readonly id: "arrayMutableReverses";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferToReversed", undefined>, _flint_fyi_core0.Rule<{
+}, "preferToReversed", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports `.sort()` calls on arrays that mutate the original array.";
   readonly id: "arrayMutableSorts";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferToSorted", undefined>, _flint_fyi_core0.Rule<{
+}, "preferToSorted", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports `Array#reduce` calls using type assertions on initial values instead of type arguments.";
   readonly id: "arrayReduceTypeArguments";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferTypeParameter", undefined>, _flint_fyi_core0.Rule<{
+}, "preferTypeParameter", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.";
   readonly id: "arraySliceUnnecessaryEnd";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryEnd", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryEnd", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports patterns that can be replaced with `.some()` for checking array element existence.";
   readonly id: "arraySomeMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferSome", undefined>, _flint_fyi_core0.Rule<{
+}, "preferSome", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports inconsistent types when spreading a ternary in an array literal.";
   readonly id: "arrayTernarySpreadingConsistency";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "inconsistentTypes", undefined>, _flint_fyi_core0.Rule<{
+}, "inconsistentTypes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports array type syntax that doesn't match the configured style.";
   readonly id: "arrayTypes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
@@ -228,145 +224,152 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferArraySyntax" | "preferGenericSyntax" | "preferReadonlyArraySyntax" | "preferReadonlyGenericSyntax", {
-  style: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  style: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     array: "array";
     "array-simple": "array-simple";
     generic: "generic";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary array length checks before `.some()` or `.every()` calls.";
   readonly id: "arrayUnnecessaryLengthChecks";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryLengthCheckEvery" | "unnecessaryLengthCheckSome", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryLengthCheckEvery" | "unnecessaryLengthCheckSome", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using explicit literal types when `as const` can be used.";
   readonly id: "asConstAssertions";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferAsConst" | "preferAsConstAnnotation", undefined>, _flint_fyi_core0.Rule<{
+}, "preferAsConst" | "preferAsConstAnnotation", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer logical assignment operator shorthand expressions.";
   readonly id: "assignmentOperatorShorthands";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferShorthand", undefined>, _flint_fyi_core0.Rule<{
+}, "preferShorthand", undefined>, import("@flint.fyi/core").Rule<{
+  readonly description: "Reports async functions that do not use await.";
+  readonly id: "asyncFunctionAwaits";
+  readonly presets: readonly ["logicalStrict"];
+} & {
+  readonly pluginId: string;
+  readonly url: string;
+}, "missingAwait", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using async functions as Promise executor functions.";
   readonly id: "asyncPromiseExecutors";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "asyncPromiseExecutor", undefined>, _flint_fyi_core0.Rule<{
+}, "asyncPromiseExecutor", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.";
   readonly id: "asyncUnnecessaryPromiseWrappers";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryReject" | "unnecessaryResolve", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryReject" | "unnecessaryResolve", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer using .at() for accessing elements at negative indices.";
   readonly id: "atAccesses";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferAt", undefined>, _flint_fyi_core0.Rule<{
+}, "preferAt", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.";
   readonly id: "builtinCoercions";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useBuiltin", undefined>, _flint_fyi_core0.Rule<{
+}, "useBuiltin", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforces using new for constructors that require it, and disallows new for primitive coercion functions.";
   readonly id: "builtinConstructorNews";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "disallowedNew" | "missingNew", undefined>, _flint_fyi_core0.Rule<{
+}, "disallowedNew" | "missingNew", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports lexical declarations in case clauses without wrapping them in blocks.";
   readonly id: "caseDeclarations";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedLexicalDeclaration", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedLexicalDeclaration", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports switch statements with duplicate case clause test expressions.";
   readonly id: "caseDuplicates";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateCase", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateCase", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports switch case clauses that fall through unexpectedly.";
   readonly id: "caseFallthroughs";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedFallthrough", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedFallthrough", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports `Promise` catch callback parameters that are not typed as unknown.";
   readonly id: "catchCallbackTypes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferUnknown", undefined>, _flint_fyi_core0.Rule<{
+}, "preferUnknown", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforces a consistent naming convention for catch clause error variables.";
   readonly id: "caughtVariableNames";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferErrorName", undefined>, _flint_fyi_core0.Rule<{
+}, "preferErrorName", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using chained assignment expressions (e.g., a = b = c).";
   readonly id: "chainedAssignments";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noChainedAssignment", undefined>, _flint_fyi_core0.Rule<{
+}, "noChainedAssignment", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports comparing charAt() results with strings longer than one character.";
   readonly id: "charAtComparisons";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "invalidComparison", undefined>, _flint_fyi_core0.Rule<{
+}, "invalidComparison", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports reassigning class declarations.";
   readonly id: "classAssignments";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noClassAssign", undefined>, _flint_fyi_core0.Rule<{
+}, "noClassAssign", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports assigning literal values to `this` in constructors instead of using class field declarations.";
   readonly id: "classFieldDeclarations";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferClassField", undefined>, _flint_fyi_core0.Rule<{
+}, "preferClassField", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports getters that return literal values instead of using readonly class fields.";
   readonly id: "classLiteralProperties";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferField", undefined>, _flint_fyi_core0.Rule<{
+}, "preferField", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports duplicate class member names that will be overwritten.";
   readonly id: "classMemberDuplicates";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateMember", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateMember", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports class methods that do not use `this`.";
   readonly id: "classMethodsThis";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
@@ -374,36 +377,36 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "missingThis", {
-  ignoreClassesThatImplementAnInterface: zod_v40.ZodDefault<zod_v40.ZodUnion<readonly [zod_v40.ZodBoolean, zod_v40.ZodLiteral<"public-fields">]>>;
-  ignoreOverrideMethods: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-}>, _flint_fyi_core0.Rule<{
+  ignoreClassesThatImplementAnInterface: import("zod/v4").ZodDefault<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodBoolean, import("zod/v4").ZodLiteral<"public-fields">]>>;
+  ignoreOverrideMethods: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports consecutive array.push() calls that could be combined into a single call.";
   readonly id: "combinedPushes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "combinePushes", undefined>, _flint_fyi_core0.Rule<{
+}, "combinePushes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary extra non-null assertions.";
   readonly id: "consecutiveNonNullAssertions";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "consecutiveNonNullAssertion", undefined>, _flint_fyi_core0.Rule<{
+}, "consecutiveNonNullAssertion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports calls to console methods.";
   readonly id: "consoleCalls";
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noConsole", undefined>, _flint_fyi_core0.Rule<{
+}, "noConsole", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports attempting to reassign variables declared with const.";
   readonly id: "constantAssignments";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noConstAssign", undefined>, _flint_fyi_core0.Rule<{
+}, "noConstAssign", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports inconsistent placement of type arguments in constructor calls.";
   readonly id: "constructorGenericCalls";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
@@ -411,297 +414,297 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferConstructor" | "preferTypeAnnotation", {
-  style: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  style: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     constructor: "constructor";
     "type-annotation": "type-annotation";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports returning values from constructor functions.";
   readonly id: "constructorReturns";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noConstructorReturn", undefined>, _flint_fyi_core0.Rule<{
+}, "noConstructorReturn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.";
   readonly id: "constructorSupers";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingSuperCall" | "unexpectedSuperCall", undefined>, _flint_fyi_core0.Rule<{
+}, "missingSuperCall" | "unexpectedSuperCall", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.";
   readonly id: "dateConstructorClones";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryGetTime", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryGetTime", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.";
   readonly id: "dateNowTimestamps";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferDateNow", undefined>, _flint_fyi_core0.Rule<{
+}, "preferDateNow", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using debugger statements.";
   readonly id: "debuggerStatements";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noDebugger", undefined>, _flint_fyi_core0.Rule<{
+}, "noDebugger", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports switch statements where the default clause is not last.";
   readonly id: "defaultCaseLast";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "defaultCaseShouldBeLast", undefined>, _flint_fyi_core0.Rule<{
+}, "defaultCaseShouldBeLast", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforce default parameters to be last.";
   readonly id: "defaultParameterLast";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "defaultParameterLast", undefined>, _flint_fyi_core0.Rule<{
+}, "defaultParameterLast", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Disallow using code marked as @deprecated.";
   readonly id: "deprecated";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "deprecated", undefined>, _flint_fyi_core0.Rule<{
+}, "deprecated", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Use destructured variables over properties for consistency.";
   readonly id: "destructuringConsistency";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useDestructured", undefined>, _flint_fyi_core0.Rule<{
+}, "useDestructured", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports functions with duplicate parameter names in their signatures.";
   readonly id: "duplicateArguments";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateParam", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateParam", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Disallow using the delete operator on computed key expressions.";
   readonly id: "dynamicDeletes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "dynamicDelete", undefined>, _flint_fyi_core0.Rule<{
+}, "dynamicDelete", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports duplicate conditions in if-else-if chains that make code unreachable.";
   readonly id: "elseIfDuplicates";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateCondition", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateCondition", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary `else` blocks following `if` statements that always return or throw.";
   readonly id: "elseReturns";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryElse", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryElse", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty block statements that should contain code.";
   readonly id: "emptyBlocks";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyBlock", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyBlock", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using empty destructuring patterns that destructure no values.";
   readonly id: "emptyDestructures";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyPattern", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyPattern", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty enum declarations with no members.";
   readonly id: "emptyEnums";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyEnum", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyEnum", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty export statements that don't make a file a module.";
   readonly id: "emptyExports";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "uselessExport", undefined>, _flint_fyi_core0.Rule<{
+}, "uselessExport", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports files that contain no meaningful code.";
   readonly id: "emptyFiles";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyFile", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyFile", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty functions that should contain code or a comment.";
   readonly id: "emptyFunctions";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyFunction", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyFunction", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty import/export attributes that serve no purpose.";
   readonly id: "emptyModuleAttributes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyAttributes", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyAttributes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty object type literals and empty interfaces that are often used incorrectly.";
   readonly id: "emptyObjectTypes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyInterface" | "emptyObjectType", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyInterface" | "emptyObjectType", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty static initialization blocks within class declarations.";
   readonly id: "emptyStaticBlocks";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyStaticBlock", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyStaticBlock", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty type parameter lists in type aliases and interfaces.";
   readonly id: "emptyTypeParameterLists";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyTypeParameters", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyTypeParameters", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports enum members without explicit initial values.";
   readonly id: "enumInitializers";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "defineInitializer", undefined>, _flint_fyi_core0.Rule<{
+}, "defineInitializer", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Requires all enum members to be literal values.";
   readonly id: "enumMemberLiterals";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "requireLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "requireLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports enums that contain both string and number members.";
   readonly id: "enumValueConsistency";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "mixedTypes", undefined>, _flint_fyi_core0.Rule<{
+}, "mixedTypes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports enum members with duplicate values.";
   readonly id: "enumValueDuplicates";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateValue", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateValue", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports negated expressions on the left side of equality checks.";
   readonly id: "equalityOperatorNegations";
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "negatedEquality", undefined>, _flint_fyi_core0.Rule<{
+}, "negatedEquality", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.";
   readonly id: "equalityOperators";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferStrictEquality", undefined>, _flint_fyi_core0.Rule<{
+}, "preferStrictEquality", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Requires a message value when creating a built-in error.";
   readonly id: "errorMessages";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingMessage", undefined>, _flint_fyi_core0.Rule<{
+}, "missingMessage", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports incorrect Error subclass definitions that don't follow best practices.";
   readonly id: "errorSubclassProperties";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "invalidClassName" | "missingName" | "redundantMessage" | "useConstructorName" | "wrongName", undefined>, _flint_fyi_core0.Rule<{
+}, "invalidClassName" | "missingName" | "redundantMessage" | "useConstructorName" | "wrongName", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.";
   readonly id: "errorUnnecessaryCaptureStackTraces";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryCaptureStackTrace", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryCaptureStackTrace", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports escape sequences with lowercase hexadecimal characters.";
   readonly id: "escapeSequenceCasing";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useUppercase", undefined>, _flint_fyi_core0.Rule<{
+}, "useUppercase", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports uses of the eval function.";
   readonly id: "evals";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noEval", undefined>, _flint_fyi_core0.Rule<{
+}, "noEval", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports variables declared without type annotation or initializer.";
   readonly id: "evolvingVariableTypes";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "implicitAny", undefined>, _flint_fyi_core0.Rule<{
+}, "implicitAny", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports reassigning exception parameters in catch clauses.";
   readonly id: "exceptionAssignments";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noExAssign", undefined>, _flint_fyi_core0.Rule<{
+}, "noExAssign", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports explicit uses of the any type.";
   readonly id: "explicitAnys";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noExplicitAny", undefined>, _flint_fyi_core0.Rule<{
+}, "noExplicitAny", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefers the ** operator over Math.pow().";
   readonly id: "exponentiationOperators";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferOperator", undefined>, _flint_fyi_core0.Rule<{
+}, "preferOperator", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports imports that are re-exported and could use export...from syntax instead.";
   readonly id: "exportFromImports";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferExportDefaultFrom" | "preferExportFrom" | "preferExportNamespaceFrom", undefined>, _flint_fyi_core0.Rule<{
+}, "preferExportDefaultFrom" | "preferExportFrom" | "preferExportNamespaceFrom", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports exporting mutable bindings (let or var).";
   readonly id: "exportMutables";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noMutableExport", undefined>, _flint_fyi_core0.Rule<{
+}, "noMutableExport", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports duplicate export names in a module.";
   readonly id: "exportUniqueNames";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateExport", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateExport", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports classes used as static namespaces.";
   readonly id: "extraneousClasses";
   readonly presets: readonly ["logicalStrict"];
@@ -709,148 +712,148 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "empty" | "onlyConstructor" | "onlyStatic", {
-  allowConstructorOnly: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  allowEmpty: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  allowStaticOnly: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  allowWithDecorator: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-}>, _flint_fyi_core0.Rule<{
+  allowConstructorOnly: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  allowEmpty: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  allowStaticOnly: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  allowWithDecorator: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Disallow providing a body with GET or HEAD fetch requests.";
   readonly id: "fetchMethodBodies";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noBody", undefined>, _flint_fyi_core0.Rule<{
+}, "noBody", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.";
   readonly id: "finallyStatementSafety";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unsafeFinally", undefined>, _flint_fyi_core0.Rule<{
+}, "unsafeFinally", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports for loops with counter variables that move in the wrong direction.";
   readonly id: "forDirections";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "wrongDirection", undefined>, _flint_fyi_core0.Rule<{
+}, "wrongDirection", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports iterating over an array with a for-in loop.";
   readonly id: "forInArrays";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "forIn", undefined>, _flint_fyi_core0.Rule<{
+}, "forIn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports for-in loops without an if statement to filter inherited properties.";
   readonly id: "forInGuards";
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingGuard", undefined>, _flint_fyi_core0.Rule<{
+}, "missingGuard", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer the spread operator over `.apply()` calls.";
   readonly id: "functionApplySpreads";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferSpread", undefined>, _flint_fyi_core0.Rule<{
+}, "preferSpread", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports reassigning variables declared with function declarations.";
   readonly id: "functionAssignments";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noFunctionAssignment", undefined>, _flint_fyi_core0.Rule<{
+}, "noFunctionAssignment", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.";
   readonly id: "functionCurryingRedundancy";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryCall", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryCall", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports functions that don't match the configured style (declaration vs expression).";
   readonly id: "functionDeclarationStyles";
 } & {
   readonly pluginId: string;
   readonly url: string;
 }, "preferDeclaration" | "preferExpression", {
-  allowArrowFunctions: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  style: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  allowArrowFunctions: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  style: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     expression: "expression";
     declaration: "declaration";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports function names that don't match the variable or property they're assigned to.";
   readonly id: "functionNameMatches";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "mismatch", undefined>, _flint_fyi_core0.Rule<{
+}, "mismatch", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the Function constructor to create functions from strings.";
   readonly id: "functionNewCalls";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noFunctionConstructor", undefined>, _flint_fyi_core0.Rule<{
+}, "noFunctionConstructor", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports generator functions that do not yield values.";
   readonly id: "generatorFunctionYields";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingYield", undefined>, _flint_fyi_core0.Rule<{
+}, "missingYield", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports getter functions that do not return values.";
   readonly id: "getterReturns";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingReturn", undefined>, _flint_fyi_core0.Rule<{
+}, "missingReturn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.";
   readonly id: "globalAssignments";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noGlobalAssign", undefined>, _flint_fyi_core0.Rule<{
+}, "noGlobalAssign", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
   readonly id: "globalObjectCalls";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noGlobalObjectCall", undefined>, _flint_fyi_core0.Rule<{
+}, "noGlobalObjectCall", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using window, self, or global instead of globalThis.";
   readonly id: "globalThisAliases";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferGlobalThis", undefined>, _flint_fyi_core0.Rule<{
+}, "preferGlobalThis", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.";
   readonly id: "impliedEvals";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "functionConstructor" | "impliedEval", undefined>, _flint_fyi_core0.Rule<{
+}, "functionConstructor" | "impliedEval", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty named import blocks.";
   readonly id: "importEmptyBlocks";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noEmptyNamedBlocksOnly" | "noEmptyNamedBlocksWithOther", undefined>, _flint_fyi_core0.Rule<{
+}, "noEmptyNamedBlocksOnly" | "noEmptyNamedBlocksWithOther", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.";
   readonly id: "importTypeSideEffects";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useTopLevelQualifier", undefined>, _flint_fyi_core0.Rule<{
+}, "useTopLevelQualifier", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports indexed object types that don't match the configured style.";
   readonly id: "indexedObjectTypes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
@@ -858,18 +861,18 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferIndexSignature" | "preferRecord", {
-  style: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  style: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     record: "record";
     "index-signature": "index-signature";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `instanceof Array` instead of `Array.isArray()`.";
   readonly id: "instanceOfArrays";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useArrayIsArray", undefined>, _flint_fyi_core0.Rule<{
+}, "useArrayIsArray", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports irregular whitespace characters that can cause issues with code parsing and display.";
   readonly id: "irregularWhitespaces";
   readonly presets: readonly ["logical"];
@@ -877,67 +880,67 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "irregularWhitespace", {
-  skipComments: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  skipJSXText: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  skipRegularExpressions: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  skipTemplates: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-}>, _flint_fyi_core0.Rule<{
+  skipComments: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  skipJSXText: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  skipRegularExpressions: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  skipTemplates: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports comparisons with NaN, which should use Number.isNaN() instead.";
   readonly id: "isNaNComparisons";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useIsNaN", undefined>, _flint_fyi_core0.Rule<{
+}, "useIsNaN", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefers literal syntax over constructor function calls for primitive values.";
   readonly id: "literalConstructorWrappers";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer modern Math methods over legacy patterns.";
   readonly id: "mathMethods";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferModernMath", undefined>, _flint_fyi_core0.Rule<{
+}, "preferModernMath", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the void operator on expressions that are already void or undefined.";
   readonly id: "meaninglessVoidOperators";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "meaninglessVoid", undefined>, _flint_fyi_core0.Rule<{
+}, "meaninglessVoid", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Require expressions of type void to appear in statement position.";
   readonly id: "misleadingVoidExpressions";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "voidExpressionArrow" | "voidExpressionReturn" | "voidExpressionValue", undefined>, _flint_fyi_core0.Rule<{
+}, "voidExpressionArrow" | "voidExpressionReturn" | "voidExpressionValue", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Require non-empty specifier lists in import and export statements.";
   readonly id: "moduleSpecifierLists";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyExportSpecifiers" | "emptyImportSpecifiers", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyExportSpecifiers" | "emptyImportSpecifiers", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports ambiguous multiline expressions that could be misinterpreted.";
   readonly id: "multilineAmbiguities";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "ambiguity", undefined>, _flint_fyi_core0.Rule<{
+}, "ambiguity", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports anonymous functions and classes as the default export.";
   readonly id: "namedDefaultExports";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "anonymousClass" | "anonymousFunction", undefined>, _flint_fyi_core0.Rule<{
+}, "anonymousClass" | "anonymousFunction", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using legacy `namespace` declarations.";
   readonly id: "namespaceDeclarations";
   readonly presets: readonly ["logical", "logicalStrict"];
@@ -945,124 +948,124 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferModules", {
-  allowDeclarations: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  allowDefinitionFiles: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-}>, _flint_fyi_core0.Rule<{
+  allowDeclarations: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  allowDefinitionFiles: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports declared namespaces that implicitly export all members.";
   readonly id: "namespaceImplicitAmbientImports";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "implicitExports", undefined>, _flint_fyi_core0.Rule<{
+}, "implicitExports", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `module` keyword instead of `namespace` for TypeScript namespaces.";
   readonly id: "namespaceKeywords";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNamespace", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNamespace", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports extending the prototype of native JavaScript objects.";
   readonly id: "nativeObjectExtensions";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noExtendNative", undefined>, _flint_fyi_core0.Rule<{
+}, "noExtendNative", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.";
   readonly id: "negativeIndexLengthMethods";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNegativeIndex", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNegativeIndex", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports comparisons with -0 that may not behave as expected.";
   readonly id: "negativeZeroComparisons";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedNegativeZeroComparison", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedNegativeZeroComparison", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.";
   readonly id: "nestedStandaloneIfs";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "lonelyIfInElse" | "lonelyIfInIf", undefined>, _flint_fyi_core0.Rule<{
+}, "lonelyIfInElse" | "lonelyIfInIf", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports misleading constructor and `new` definitions in interfaces and classes.";
   readonly id: "newDefinitions";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "classMethodNamedNew" | "interfaceConstructSignature" | "interfaceMethodNamedConstructor", undefined>, _flint_fyi_core0.Rule<{
+}, "classMethodNamedNew" | "interfaceConstructSignature" | "interfaceMethodNamedConstructor", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports standalone new expressions that don't use the constructed object.";
   readonly id: "newExpressions";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noStandaloneNew", undefined>, _flint_fyi_core0.Rule<{
+}, "noStandaloneNew", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
   readonly id: "newNativeNonConstructors";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noNewNonConstructor", undefined>, _flint_fyi_core0.Rule<{
+}, "noNewNonConstructor", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports type assertions that can be replaced with non-null assertions.";
   readonly id: "nonNullableTypeAssertions";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNonNullAssertion", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNonNullAssertion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports non-null assertions on the left side of nullish coalescing operators.";
   readonly id: "nonNullAssertedNullishCoalesces";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryNonNullAssertion", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryNonNullAssertion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports non-null assertions on optional chain expressions.";
   readonly id: "nonNullAssertedOptionalChains";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "nonNullOptionalChain", undefined>, _flint_fyi_core0.Rule<{
+}, "nonNullOptionalChain", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.";
   readonly id: "nonNullAssertionPlacement";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "confusingAssign" | "confusingEqual" | "confusingOperator", undefined>, _flint_fyi_core0.Rule<{
+}, "confusingAssign" | "confusingEqual" | "confusingOperator", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
   readonly id: "nonOctalDecimalEscapes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforces consistent equality operator usage when comparing with null or undefined.";
   readonly id: "nullishCheckStyle";
 } & {
   readonly pluginId: string;
   readonly url: string;
 }, "preferLooseNull" | "preferLooseNullish" | "preferLooseUndefined" | "preferStrictNullish", {
-  looseNullishComparisonStyle: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  looseNullishComparisonStyle: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     "prefer-null": "prefer-null";
     "prefer-undefined": "prefer-undefined";
     ignore: "ignore";
   }>>;
-  nullishComparisonStrictness: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  nullishComparisonStrictness: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     ignore: "ignore";
     "double-equals": "double-equals";
     "triple-equals": "triple-equals";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer nullish coalescing operator (??) over logical OR (||) for nullish values.";
   readonly id: "nullishCoalescingOperators";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
@@ -1070,171 +1073,171 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferNullish" | "preferNullishAssignment" | "preferNullishTernary", {
-  ignoreConditionalTests: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  ignoreIfStatements: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  ignoreMixedLogicalExpressions: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-  ignorePrimitives: zod_v40.ZodDefault<zod_v40.ZodUnion<readonly [zod_v40.ZodBoolean, zod_v40.ZodRecord<zod_v40.ZodEnum<{
+  ignoreConditionalTests: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  ignoreIfStatements: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  ignoreMixedLogicalExpressions: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+  ignorePrimitives: import("zod/v4").ZodDefault<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodBoolean, import("zod/v4").ZodRecord<import("zod/v4").ZodEnum<{
     string: "string";
     number: "number";
     bigint: "bigint";
     boolean: "boolean";
-  }>, zod_v40.ZodBoolean>]>>;
-  ignoreTernaryTests: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-}>, _flint_fyi_core0.Rule<{
+  }>, import("zod/v4").ZodBoolean>]>>;
+  ignoreTernaryTests: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports when number method arguments are outside their valid range.";
   readonly id: "numberMethodRanges";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "outOfRange", undefined>, _flint_fyi_core0.Rule<{
+}, "outOfRange", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using legacy global functions instead of `Number` static methods.";
   readonly id: "numberStaticMethods";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNumberMethod", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNumberMethod", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports operations that always result in zero, such as multiplication by zero.";
   readonly id: "numericErasingOperations";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "erasingOperation", undefined>, _flint_fyi_core0.Rule<{
+}, "erasingOperation", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.";
   readonly id: "numericLiteralParsing";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports numeric literals that lose precision when converted to JavaScript numbers.";
   readonly id: "numericPrecision";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "lossOfPrecision", undefined>, _flint_fyi_core0.Rule<{
+}, "lossOfPrecision", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports numeric literals with inconsistent separator grouping.";
   readonly id: "numericSeparatorGroups";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "invalidGrouping", undefined>, _flint_fyi_core0.Rule<{
+}, "invalidGrouping", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer object spread syntax over `Object.assign()` when the first argument is an object literal.";
   readonly id: "objectAssignSpreads";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferObjectLiteral" | "preferObjectSpread", undefined>, _flint_fyi_core0.Rule<{
+}, "preferObjectLiteral" | "preferObjectSpread", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.";
   readonly id: "objectCalls";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferObjectLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "preferObjectLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer Object.fromEntries() over reduce patterns that build objects from key-value pairs.";
   readonly id: "objectEntriesMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferFromEntries", undefined>, _flint_fyi_core0.Rule<{
+}, "preferFromEntries", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.";
   readonly id: "objectHasOwns";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferHasOwn", undefined>, _flint_fyi_core0.Rule<{
+}, "preferHasOwn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary duplicate keys that override previous values.";
   readonly id: "objectKeyDuplicates";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicateKey", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicateKey", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
   readonly id: "objectProto";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noProto", undefined>, _flint_fyi_core0.Rule<{
+}, "noProto", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports direct calls to Object.prototype methods on object instances.";
   readonly id: "objectPrototypeBuiltIns";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "prototypeBuiltIn", undefined>, _flint_fyi_core0.Rule<{
+}, "prototypeBuiltIn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Object property and method definitions can use shorthand syntax when the key matches the value identifier or when a function expression is assigned.";
   readonly id: "objectShorthand";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "expectedMethodShorthand" | "expectedPropertyShorthand", undefined>, _flint_fyi_core0.Rule<{
+}, "expectedMethodShorthand" | "expectedPropertyShorthand", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty object fallbacks in object spread expressions that have no effect.";
   readonly id: "objectSpreadUnnecessaryFallbacks";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryFallback", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryFallback", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer interface declarations over type aliases for object types.";
   readonly id: "objectTypeDefinitions";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferInterface", undefined>, _flint_fyi_core0.Rule<{
+}, "preferInterface", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using octal escape sequences in string literals.";
   readonly id: "octalEscapes";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noOctalEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "noOctalEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using legacy octal numeric literals.";
   readonly id: "octalNumbers";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noOctalNumber", undefined>, _flint_fyi_core0.Rule<{
+}, "noOctalNumber", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer assignment operator shorthand where possible.";
   readonly id: "operatorAssignmentShorthand";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferShorthand", undefined>, _flint_fyi_core0.Rule<{
+}, "preferShorthand", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Require that function overload signatures be consecutive.";
   readonly id: "overloadSignaturesAdjacent";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "overloadSignatureSeparated", undefined>, _flint_fyi_core0.Rule<{
+}, "overloadSignatureSeparated", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Disallow reassignment of function parameters.";
   readonly id: "parameterReassignments";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "parameterReassignment", undefined>, _flint_fyi_core0.Rule<{
+}, "parameterReassignment", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports parseInt calls that are missing or have an invalid radix parameter.";
   readonly id: "parseIntRadixes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "invalidRadix" | "missingRadix", undefined>, _flint_fyi_core0.Rule<{
+}, "invalidRadix" | "missingRadix", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports bracket notation property access when dot notation can be used.";
   readonly id: "propertyAccessNotation";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
@@ -1242,572 +1245,572 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "preferDotNotation", {
-  allowIndexSignaturePropertyAccess: zod_v40.ZodDefault<zod_v40.ZodBoolean>;
-}>, _flint_fyi_core0.Rule<{
+  allowIndexSignaturePropertyAccess: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports function parameters that are only used in recursive calls.";
   readonly id: "recursionOnlyArguments";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "onlyUsedInRecursion", undefined>, _flint_fyi_core0.Rule<{
+}, "onlyUsedInRecursion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports union and intersection type constituents that are redundant or override other types.";
   readonly id: "redundantTypeConstituents";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", undefined>, _flint_fyi_core0.Rule<{
+}, "errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.";
   readonly id: "regexAllGlobalFlags";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingGlobalFlag", undefined>, _flint_fyi_core0.Rule<{
+}, "missingGlobalFlag", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regex patterns that use ambiguous or invalid syntax from Annex B.";
   readonly id: "regexAmbiguousInvalidity";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "incompleteBackreference" | "incompleteEscapeSequence" | "invalidControlEscape" | "invalidPropertyEscape" | "invalidRange" | "octalEscape" | "quantifiedAssertion" | "regexMessage" | "unescapedSourceCharacter" | "uselessEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "incompleteBackreference" | "incompleteEscapeSequence" | "invalidControlEscape" | "invalidPropertyEscape" | "invalidRange" | "octalEscape" | "quantifiedAssertion" | "regexMessage" | "unescapedSourceCharacter" | "uselessEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regex alternations that can be simplified to character classes.";
   readonly id: "regexCharacterClasses";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferCharacterClass", undefined>, _flint_fyi_core0.Rule<{
+}, "preferCharacterClass", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports character class elements that can be simplified to ranges.";
   readonly id: "regexCharacterClassRanges";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferRange", undefined>, _flint_fyi_core0.Rule<{
+}, "preferRange", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports lookarounds that can be replaced with character class set operations.";
   readonly id: "regexCharacterClassSetOperations";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferSetOperation", undefined>, _flint_fyi_core0.Rule<{
+}, "preferSetOperation", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports negated character classes that can use shorthand escapes.";
   readonly id: "regexConciseCharacterClassNegations";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNegatedEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNegatedEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports elements in regular expressions that contradict assertions.";
   readonly id: "regexContradictoryAssertions";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "alwaysEnter" | "cannotEnter", undefined>, _flint_fyi_core0.Rule<{
+}, "alwaysEnter" | "cannotEnter", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports control characters that are not escaped using standard escape sequences.";
   readonly id: "regexControlCharacterEscapes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferStandardEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "preferStandardEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports control characters in regular expressions.";
   readonly id: "regexControlCharacters";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedControlChar", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedControlChar", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports character classes with multiple adjacent characters that could use a range instead.";
   readonly id: "regexDigitMatchers";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferRange", undefined>, _flint_fyi_core0.Rule<{
+}, "preferRange", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports replacement strings with unescaped `$` that should use `$$`.";
   readonly id: "regexDollarEscapes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unescapedDollar", undefined>, _flint_fyi_core0.Rule<{
+}, "unescapedDollar", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports duplicate characters in regular expression character classes.";
   readonly id: "regexDuplicateCharacterClassCharacters";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "duplicate" | "includedInRange", undefined>, _flint_fyi_core0.Rule<{
+}, "duplicate" | "includedInRange", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty alternatives in regular expressions that may indicate a mistake.";
   readonly id: "regexEmptyAlternatives";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyAlternative", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyAlternative", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports capturing groups that only capture empty strings.";
   readonly id: "regexEmptyCapturingGroups";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyCapture", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyCapture", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports character classes that match no characters.";
   readonly id: "regexEmptyCharacterClasses";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "empty", undefined>, _flint_fyi_core0.Rule<{
+}, "empty", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty groups in regular expressions.";
   readonly id: "regexEmptyGroups";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyGroup", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyGroup", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports lazy quantifiers at the end of regular expressions.";
   readonly id: "regexEmptyLazyQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "uselessElement" | "uselessQuantifier" | "uselessRange", undefined>, _flint_fyi_core0.Rule<{
+}, "uselessElement" | "uselessQuantifier" | "uselessRange", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty lookahead and lookbehind assertions in regular expressions.";
   readonly id: "regexEmptyLookaroundsAssertions";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyLookaround", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyLookaround", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports empty string literals in character classes.";
   readonly id: "regexEmptyStringLiterals";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "emptyStringLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "emptyStringLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports escape backspace (`[\\b]`) in character classes.";
   readonly id: "regexEscapeBackspaces";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "escapeBackspace", undefined>, _flint_fyi_core0.Rule<{
+}, "escapeBackspace", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports String.prototype.match calls that can be replaced with RegExp.prototype.exec.";
   readonly id: "regexExecutors";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferExec", undefined>, _flint_fyi_core0.Rule<{
+}, "preferExec", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports string literals inside character classes with the `v` flag that contain multiple graphemes.";
   readonly id: "regexGraphemeStringLiterals";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "multipleGraphemes", undefined>, _flint_fyi_core0.Rule<{
+}, "multipleGraphemes", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.";
   readonly id: "regexHexadecimalEscapes";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferHexEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "preferHexEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regex patterns that can be simplified by using the i (ignore case) flag.";
   readonly id: "regexIgnoreCaseFlags";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useIgnoreCase", undefined>, _flint_fyi_core0.Rule<{
+}, "useIgnoreCase", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports invisible characters in regex patterns that should use escape sequences instead.";
   readonly id: "regexInvisibleCharacters";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedInvisible", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedInvisible", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports inconsistent letter casing in regex sequences.";
   readonly id: "regexLetterCasing";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpectedCase", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpectedCase", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Use a regular expression literal when the pattern is static.";
   readonly id: "regexLiterals";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferLiteral", undefined>, _flint_fyi_core0.Rule<{
+}, "preferLiteral", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.";
   readonly id: "regexLookaroundAssertions";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferLookaround", undefined>, _flint_fyi_core0.Rule<{
+}, "preferLookaround", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports non-constant quantifiers in lookaround assertions that could be simplified.";
   readonly id: "regexLookaroundQuantifierOptimizations";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "replace" | "remove", undefined>, _flint_fyi_core0.Rule<{
+}, "replace" | "remove", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports inconsistent notations for matching any character in regular expressions.";
   readonly id: "regexMatchNotation";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpected", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpected", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports capturing groups that capture less text than their pattern suggests.";
   readonly id: "regexMisleadingCapturingGroups";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "misleadingEnd" | "misleadingStart", undefined>, _flint_fyi_core0.Rule<{
+}, "misleadingEnd" | "misleadingStart", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers whose minimum implies they must match but whose element can match empty.";
   readonly id: "regexMisleadingQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "confusing", undefined>, _flint_fyi_core0.Rule<{
+}, "confusing", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.";
   readonly id: "regexMisleadingUnicodeCharacters";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "combiningClass" | "emojiModifier" | "regionalIndicatorSymbol" | "surrogatePair" | "surrogatePairWithoutUFlag" | "zwj", undefined>, _flint_fyi_core0.Rule<{
+}, "combiningClass" | "emojiModifier" | "regionalIndicatorSymbol" | "surrogatePair" | "surrogatePairWithoutUFlag" | "zwj", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports backreferences that do not use the name of their referenced capturing group.";
   readonly id: "regexNamedBackreferences";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNamed", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNamed", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports capturing groups in regular expressions that do not have a name.";
   readonly id: "regexNamedCaptureGroups";
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNamed", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNamed", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports indexed references in replacement strings that should use named references.";
   readonly id: "regexNamedReplacements";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNamed", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNamed", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports non-standard regular expression flags.";
   readonly id: "regexNonStandardFlags";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpected", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpected", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports obscure character ranges in regular expressions.";
   readonly id: "regexObscureRanges";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "obscure", undefined>, _flint_fyi_core0.Rule<{
+}, "obscure", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports octal escape sequences in regular expressions.";
   readonly id: "regexOctalEscapes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unexpected", undefined>, _flint_fyi_core0.Rule<{
+}, "unexpected", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers `{1,}` in regular expressions that should use `+` instead.";
   readonly id: "regexPlusQuantifiers";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferPlus", undefined>, _flint_fyi_core0.Rule<{
+}, "preferPlus", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regex lookarounds that can be replaced with predefined assertions.";
   readonly id: "regexPredefinedAssertions";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferPredefinedAssertion", undefined>, _flint_fyi_core0.Rule<{
+}, "preferPredefinedAssertion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers `{0,1}` in regular expressions that should use `?` instead.";
   readonly id: "regexQuestionQuantifiers";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferOptionalGroup" | "preferQuestion", undefined>, _flint_fyi_core0.Rule<{
+}, "preferOptionalGroup" | "preferQuestion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports consecutive identical elements in regular expressions that should use quantifiers.";
   readonly id: "regexRepeatQuantifiers";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferQuantifier", undefined>, _flint_fyi_core0.Rule<{
+}, "preferQuantifier", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports indexed access on regex result arrays when named capturing groups should be used.";
   readonly id: "regexResultArrayGroups";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferGroups", undefined>, _flint_fyi_core0.Rule<{
+}, "preferGroups", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports set operations in regular expressions that can be simplified.";
   readonly id: "regexSetOperationOptimizations";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "toIntersection" | "toNegationOfConjunction" | "toNegationOfDisjunction" | "toSubtraction", undefined>, _flint_fyi_core0.Rule<{
+}, "toIntersection" | "toNegationOfConjunction" | "toNegationOfDisjunction" | "toSubtraction", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports standalone backslashes in regex patterns that look like incomplete escape sequences.";
   readonly id: "regexStandaloneBackslashes";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "standaloneBackslash", undefined>, _flint_fyi_core0.Rule<{
+}, "standaloneBackslash", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers `{0,}` in regular expressions that should use `*` instead.";
   readonly id: "regexStarQuantifiers";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferStar", undefined>, _flint_fyi_core0.Rule<{
+}, "preferStar", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regular expressions with exponential or polynomial backtracking.";
   readonly id: "regexSuperLinearBacktracking";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "self" | "trade", undefined>, _flint_fyi_core0.Rule<{
+}, "self" | "trade", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers that can cause quadratic regex matching time.";
   readonly id: "regexSuperLinearMoves";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "superLinear", undefined>, _flint_fyi_core0.Rule<{
+}, "superLinear", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports match() and exec() calls that should use RegExp.prototype.test() for boolean checks.";
   readonly id: "regexTestMethods";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferTest", undefined>, _flint_fyi_core0.Rule<{
+}, "preferTest", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports surrogate pair escapes in regular expressions that can be replaced with Unicode codepoint escapes.";
   readonly id: "regexUnicodeCodepointEscapes";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "useSurrogatePair", undefined>, _flint_fyi_core0.Rule<{
+}, "useSurrogatePair", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforces consistent Unicode escape style in regex patterns by preferring codepoint escapes.";
   readonly id: "regexUnicodeEscapes";
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferCodepointEscape", undefined>, _flint_fyi_core0.Rule<{
+}, "preferCodepointEscape", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Require regex patterns to have the unicode ('u') or unicodeSets ('v') flag for proper Unicode character handling.";
   readonly id: "regexUnicodeFlag";
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missing", undefined>, _flint_fyi_core0.Rule<{
+}, "missing", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports inconsistent Unicode property names in regular expressions.";
   readonly id: "regexUnicodeProperties";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferLongScript" | "unnecessaryPrefix", undefined>, _flint_fyi_core0.Rule<{
+}, "preferLongScript" | "unnecessaryPrefix", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports assertions in regular expressions that always reject.";
   readonly id: "regexUnnecessaryAssertions";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "endAnchor" | "negatedWordBoundary" | "startAnchor" | "wordBoundary", undefined>, _flint_fyi_core0.Rule<{
+}, "endAnchor" | "negatedWordBoundary" | "startAnchor" | "wordBoundary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports backreferences in regular expressions that will always match empty or fail.";
   readonly id: "regexUnnecessaryBackreferences";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "nested" | "disjunctive" | "intoNegativeLookaround" | "forward" | "backward", undefined>, _flint_fyi_core0.Rule<{
+}, "nested" | "disjunctive" | "intoNegativeLookaround" | "forward" | "backward", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports character classes that wrap a single element that does not require brackets.";
   readonly id: "regexUnnecessaryCharacterClasses";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessary", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports character class ranges that span only one or two characters.";
   readonly id: "regexUnnecessaryCharacterRanges";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "adjacent" | "identity", undefined>, _flint_fyi_core0.Rule<{
+}, "adjacent" | "identity", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports single-character alternatives in string disjunctions.";
   readonly id: "regexUnnecessaryDisjunctions";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessary", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports replacement string references to capturing groups that do not exist in the pattern.";
   readonly id: "regexUnnecessaryDollarReplacements";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "namedNotFound" | "numericNotFound", undefined>, _flint_fyi_core0.Rule<{
+}, "namedNotFound" | "numericNotFound", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary escape sequences in regular expressions.";
   readonly id: "regexUnnecessaryEscapes";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessary", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary nested lookaround assertions in regular expressions.";
   readonly id: "regexUnnecessaryLookaroundAssertions";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "lookahead" | "lookbehind", undefined>, _flint_fyi_core0.Rule<{
+}, "lookahead" | "lookbehind", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports trivially nested assertions in regular expressions that can be simplified.";
   readonly id: "regexUnnecessaryNestedAssertions";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryNesting", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryNesting", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports trivially nested quantifiers in regular expressions that can be simplified.";
   readonly id: "regexUnnecessaryNestedQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryNestedQuantifiers", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryNestedQuantifiers", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports non-capturing groups that can be removed without changing the meaning of the regex.";
   readonly id: "regexUnnecessaryNonCapturingGroups";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryGroup", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryGroup", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports numeric quantifiers like '{n,n}' that can be simplified to '{n}'.";
   readonly id: "regexUnnecessaryNumericQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryNumericQuantifier", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryNumericQuantifier", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports assertions inside optional quantifiers that have no effect.";
   readonly id: "regexUnnecessaryOptionalAssertions";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryOptionalAssertion", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryOptionalAssertion", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports backreferences that may reference a capturing group that was not matched.";
   readonly id: "regexUnnecessaryReferentialBackreferences";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "potentiallyUselessBackref", undefined>, _flint_fyi_core0.Rule<{
+}, "potentiallyUselessBackref", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary operands in regular expression character class set operations.";
   readonly id: "regexUnnecessarySetOperands";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "intersectionDisjoint" | "intersectionSubset" | "subtractionDisjoint" | "subtractionSubset", undefined>, _flint_fyi_core0.Rule<{
+}, "intersectionDisjoint" | "intersectionSubset" | "subtractionDisjoint" | "subtractionSubset", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports capturing groups in regular expressions that are never referenced.";
   readonly id: "regexUnusedCapturingGroups";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unusedCapture", undefined>, _flint_fyi_core0.Rule<{
+}, "unusedCapture", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regular expression flags that have no effect on the pattern.";
   readonly id: "regexUnusedFlags";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unusedDotAll" | "unusedIgnoreCase" | "unusedMultiline", undefined>, _flint_fyi_core0.Rule<{
+}, "unusedDotAll" | "unusedIgnoreCase" | "unusedMultiline", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports lazy quantifiers that have no effect because the quantifier is constant.";
   readonly id: "regexUnusedLazyQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "uselessLazy", undefined>, _flint_fyi_core0.Rule<{
+}, "uselessLazy", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers that match exactly once, making them unnecessary.";
   readonly id: "regexUnusedQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "uselessQuantifier", undefined>, _flint_fyi_core0.Rule<{
+}, "uselessQuantifier", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports invalid regular expressions.";
   readonly id: "regexValidity";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "conflictingFlags" | "duplicateFlag" | "invalidFlag" | "invalidPattern", undefined>, _flint_fyi_core0.Rule<{
+}, "conflictingFlags" | "duplicateFlag" | "invalidFlag" | "invalidPattern", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports character classes that match word characters and could use \\w or \\W instead.";
   readonly id: "regexWordMatchers";
   readonly presets: readonly ["stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferWord", undefined>, _flint_fyi_core0.Rule<{
+}, "preferWord", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports quantifiers with a maximum of zero, which are useless.";
   readonly id: "regexZeroQuantifiers";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "uselessZero", undefined>, _flint_fyi_core0.Rule<{
+}, "uselessZero", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports CommonJS require() imports in favor of ES module imports.";
   readonly id: "requireImports";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noRequireImports", undefined>, _flint_fyi_core0.Rule<{
+}, "noRequireImports", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports CommonJS require() imports in favor of ES module imports.";
   readonly id: "requireImports";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noRequireImports", undefined>, _flint_fyi_core0.Rule<{
+}, "noRequireImports", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer `Response.json()` over `new Response(JSON.stringify(...))` for JSON responses.";
   readonly id: "responseJsonMethods";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferResponseJson", undefined>, _flint_fyi_core0.Rule<{
+}, "preferResponseJson", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Disallows specific identifier names in binding positions.";
   readonly id: "restrictedIdentifiers";
   readonly presets: readonly ["stylisticStrict"];
@@ -1815,64 +1818,87 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "restricted", {
-  deny: zod_v40.ZodOptional<zod_v40.ZodArray<zod_v40.ZodString>>;
-}>, _flint_fyi_core0.Rule<{
+  deny: import("zod/v4").ZodOptional<import("zod/v4").ZodArray<import("zod/v4").ZodString>>;
+}>, import("@flint.fyi/core").Rule<{
+  readonly description: "Restricts specified modules from being imported.";
+  readonly id: "restrictedImports";
+} & {
+  readonly pluginId: string;
+  readonly url: string;
+}, "restricted" | "moduleRestricted" | "moduleRestrictedWithMessage" | "namespaceRestricted" | "namespaceRestrictedWithMessage" | "restrictedWithMessage", {
+  restrictions: import("zod/v4").ZodDefault<import("zod/v4").ZodArray<import("zod/v4").ZodObject<{
+    allowTypeImports: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+    message: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    specifier: import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodObject<{
+      from: import("zod/v4").ZodLiteral<"file">;
+      name: import("zod/v4").ZodOptional<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodArray<import("zod/v4").ZodString>]>>;
+      path: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+    }, import("zod/v4/core").$strip>, import("zod/v4").ZodObject<{
+      from: import("zod/v4").ZodLiteral<"lib">;
+      name: import("zod/v4").ZodOptional<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodArray<import("zod/v4").ZodString>]>>;
+    }, import("zod/v4/core").$strip>, import("zod/v4").ZodObject<{
+      from: import("zod/v4").ZodLiteral<"package">;
+      name: import("zod/v4").ZodOptional<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodString, import("zod/v4").ZodArray<import("zod/v4").ZodString>]>>;
+      package: import("zod/v4").ZodString;
+    }, import("zod/v4/core").$strip>]>;
+  }, import("zod/v4/core").$strip>>>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using assignment expressions in return statements.";
   readonly id: "returnAssignments";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noReturnAssign", undefined>, _flint_fyi_core0.Rule<{
+}, "noReturnAssign", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforce that `this` is used when only `this` type is returned.";
   readonly id: "returnThisTypes";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferThis", undefined>, _flint_fyi_core0.Rule<{
+}, "preferThis", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports self-assignments which have no effect and are likely errors.";
   readonly id: "selfAssignments";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "selfAssignment", undefined>, _flint_fyi_core0.Rule<{
+}, "selfAssignment", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the comma operator in expressions.";
   readonly id: "sequences";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noSequences", undefined>, _flint_fyi_core0.Rule<{
+}, "noSequences", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Prefer `Set.size` over spreading into an array and accessing `.length`.";
   readonly id: "setSizeLengthChecks";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferSize", undefined>, _flint_fyi_core0.Rule<{
+}, "preferSize", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports return statements with values inside setters.";
   readonly id: "setterReturns";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noSetterReturn", undefined>, _flint_fyi_core0.Rule<{
+}, "noSetterReturn", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
   readonly id: "shadowedRestrictedNames";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "shadowedRestrictedName", undefined>, _flint_fyi_core0.Rule<{
+}, "shadowedRestrictedName", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforces one variable per declaration statement.";
   readonly id: "singleVariableDeclarations";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "singleVariable", undefined>, _flint_fyi_core0.Rule<{
+}, "singleVariable", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Enforce consistent style for `.length` and `.size` checks.";
   readonly id: "sizeComparisonOperators";
   readonly presets: readonly ["stylisticStrict"];
@@ -1880,109 +1906,109 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "coercionNonZeroCheck" | "coercionZeroCheck" | "explicitNonZeroCheck" | "explicitZeroCheck", {
-  style: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  style: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     coercion: "coercion";
     explicit: "explicit";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports array literals with holes (sparse arrays).";
   readonly id: "sparseArrays";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noSparseArray", undefined>, _flint_fyi_core0.Rule<{
+}, "noSparseArray", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports classes that only contain static members.";
   readonly id: "staticMemberOnlyClasses";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noStaticOnlyClass", undefined>, _flint_fyi_core0.Rule<{
+}, "noStaticOnlyClass", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports string case method calls compared against literals with mismatched casing.";
   readonly id: "stringCaseMismatches";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "mismatch", undefined>, _flint_fyi_core0.Rule<{
+}, "mismatch", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports usage of charCodeAt and fromCharCode instead of their codePoint equivalents.";
   readonly id: "stringCodePoints";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferCodePointAt" | "preferFromCodePoint", undefined>, _flint_fyi_core0.Rule<{
+}, "preferCodePointAt" | "preferFromCodePoint", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports usage of `substring` instead of slice for string operations.";
   readonly id: "stringSliceMethods";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferSliceOverSubstring", undefined>, _flint_fyi_core0.Rule<{
+}, "preferSliceOverSubstring", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports regex patterns that can be replaced with `endsWith` or `startsWith`.";
   readonly id: "stringStartsEndsWith";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferEndsWith" | "preferStartsWith", undefined>, _flint_fyi_core0.Rule<{
+}, "preferEndsWith" | "preferStartsWith", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.";
   readonly id: "structuredCloneMethods";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferStructuredClone", undefined>, _flint_fyi_core0.Rule<{
+}, "preferStructuredClone", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports Symbol() calls without description arguments.";
   readonly id: "symbolDescriptions";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "missingDescription", undefined>, _flint_fyi_core0.Rule<{
+}, "missingDescription", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports assigning `this` to a variable.";
   readonly id: "thisAliases";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noThisAlias", undefined>, _flint_fyi_core0.Rule<{
+}, "noThisAlias", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using `this` or `super` before calling `super()` in derived class constructors.";
   readonly id: "thisBeforeSuper";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "thisBeforeSuper" | "superBeforeSuper", undefined>, _flint_fyi_core0.Rule<{
+}, "thisBeforeSuper" | "superBeforeSuper", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports throwing values that are not `Error` objects.";
   readonly id: "throwErrors";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "throwError" | "throwUndefined", undefined>, _flint_fyi_core0.Rule<{
+}, "throwError" | "throwUndefined", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports top-level await expressions in files that export values.";
   readonly id: "topLevelAwaits";
   readonly presets: readonly ["logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "topLevelAwait", undefined>, _flint_fyi_core0.Rule<{
+}, "topLevelAwait", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports triple-slash reference directives.";
   readonly id: "tripleSlashReferences";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noTripleSlashReference", undefined>, _flint_fyi_core0.Rule<{
+}, "noTripleSlashReference", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports invalid triple-slash reference directives.";
   readonly id: "tripleSlashReferenceValidity";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "invalidDirective", undefined>, _flint_fyi_core0.Rule<{
+}, "invalidDirective", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports problematic TypeScript comment directives or requires descriptions after directives.";
   readonly id: "tsComments";
   readonly presets: readonly ["logical"];
@@ -1990,31 +2016,31 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "descriptionNotMatchPattern" | "directiveComment" | "preferExpectError" | "requiresDescription", {
-  allowTsExpectError: zod_v40.ZodDefault<zod_v40.ZodUnion<readonly [zod_v40.ZodLiteral<true>, zod_v40.ZodLiteral<false>, zod_v40.ZodLiteral<"allow-with-description">, zod_v40.ZodObject<{
-    descriptionFormat: zod_v40.ZodString;
-  }, zod_v4_core0.$strip>]>>;
-  allowTsIgnore: zod_v40.ZodDefault<zod_v40.ZodUnion<readonly [zod_v40.ZodLiteral<true>, zod_v40.ZodLiteral<false>, zod_v40.ZodLiteral<"allow-with-description">, zod_v40.ZodObject<{
-    descriptionFormat: zod_v40.ZodString;
-  }, zod_v4_core0.$strip>]>>;
-  allowTsNocheck: zod_v40.ZodDefault<zod_v40.ZodUnion<readonly [zod_v40.ZodLiteral<true>, zod_v40.ZodLiteral<false>, zod_v40.ZodLiteral<"allow-with-description">, zod_v40.ZodObject<{
-    descriptionFormat: zod_v40.ZodString;
-  }, zod_v4_core0.$strip>]>>;
-  minimumDescriptionLength: zod_v40.ZodDefault<zod_v40.ZodNumber>;
-}>, _flint_fyi_core0.Rule<{
+  allowTsExpectError: import("zod/v4").ZodDefault<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<true>, import("zod/v4").ZodLiteral<false>, import("zod/v4").ZodLiteral<"allow-with-description">, import("zod/v4").ZodObject<{
+    descriptionFormat: import("zod/v4").ZodString;
+  }, import("zod/v4/core").$strip>]>>;
+  allowTsIgnore: import("zod/v4").ZodDefault<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<true>, import("zod/v4").ZodLiteral<false>, import("zod/v4").ZodLiteral<"allow-with-description">, import("zod/v4").ZodObject<{
+    descriptionFormat: import("zod/v4").ZodString;
+  }, import("zod/v4/core").$strip>]>>;
+  allowTsNocheck: import("zod/v4").ZodDefault<import("zod/v4").ZodUnion<readonly [import("zod/v4").ZodLiteral<true>, import("zod/v4").ZodLiteral<false>, import("zod/v4").ZodLiteral<"allow-with-description">, import("zod/v4").ZodObject<{
+    descriptionFormat: import("zod/v4").ZodString;
+  }, import("zod/v4/core").$strip>]>>;
+  minimumDescriptionLength: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports TSLint disable/enable comments.";
   readonly id: "tslintComments";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "tslintComment", undefined>, _flint_fyi_core0.Rule<{
+}, "tslintComment", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports angle-bracket type assertions.";
   readonly id: "typeAssertionStyles";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferAs", undefined>, _flint_fyi_core0.Rule<{
+}, "preferAs", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports imports that do not match the configured type import style.";
   readonly id: "typeImports";
   readonly presets: readonly ["stylistic"];
@@ -2022,162 +2048,162 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly pluginId: string;
   readonly url: string;
 }, "avoidImportType" | "someImportsAreOnlyTypes" | "typeOverValue", {
-  fixStyle: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  fixStyle: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     "inline-type-imports": "inline-type-imports";
     "separate-type-imports": "separate-type-imports";
   }>>;
-  prefer: zod_v40.ZodDefault<zod_v40.ZodEnum<{
+  prefer: import("zod/v4").ZodDefault<import("zod/v4").ZodEnum<{
     "no-type-imports": "no-type-imports";
     "type-imports": "type-imports";
   }>>;
-}>, _flint_fyi_core0.Rule<{
+}>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports typeof expressions that compare impossible string literals.";
   readonly id: "typeofComparisons";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "invalidValue", undefined>, _flint_fyi_core0.Rule<{
+}, "invalidValue", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports variables that are declared but never assigned a value.";
   readonly id: "unassignedVariables";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noUnassigned", undefined>, _flint_fyi_core0.Rule<{
+}, "noUnassigned", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports typeof undefined checks.";
   readonly id: "undefinedTypeofChecks";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "directComparison", undefined>, _flint_fyi_core0.Rule<{
+}, "directComparison", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using variables that are not defined.";
   readonly id: "undefinedVariables";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "undefinedVariable", undefined>, _flint_fyi_core0.Rule<{
+}, "undefinedVariable", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
   readonly id: "unicodeBOMs";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noBOM", undefined>, _flint_fyi_core0.Rule<{
+}, "noBOM", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary `.bind()` calls.";
   readonly id: "unnecessaryBinds";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryBinds" | "arrowBind", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryBinds" | "arrowBind", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports standalone block statements that don't create a meaningful scope.";
   readonly id: "unnecessaryBlocks";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryBlock", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryBlock", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary boolean casts.";
   readonly id: "unnecessaryBooleanCasts";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessary", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
   readonly id: "unnecessaryCatches";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryCatch", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryCatch", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports comparisons that are always true, always false, or can be simplified.";
   readonly id: "unnecessaryComparisons";
   readonly presets: readonly ["logical", "logicalStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", undefined>, _flint_fyi_core0.Rule<{
+}, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
   readonly id: "unnecessaryConcatenation";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryConcatenation", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryConcatenation", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary escape sequences in string literals and template strings.";
   readonly id: "unnecessaryEscapes";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessary", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.";
   readonly id: "unnecessaryMathClamps";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "constantArguments" | "incorrectClampOrder", undefined>, _flint_fyi_core0.Rule<{
+}, "constantArguments" | "incorrectClampOrder", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports numeric literals with unnecessary zero fractions or dangling dots.";
   readonly id: "unnecessaryNumericFractions";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "danglingDot" | "zeroFraction", undefined>, _flint_fyi_core0.Rule<{
+}, "danglingDot" | "zeroFraction", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Renames that don't change the identifier name are unnecessary.";
   readonly id: "unnecessaryRenames";
   readonly presets: readonly ["stylistic"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryRename", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryRename", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators";
   readonly id: "unnecessaryTernaries";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports unnecessary \"use strict\" directives in ES modules and classes.";
   readonly id: "unnecessaryUseStricts";
   readonly presets: readonly ["logical"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "unnecessaryUseStrict", undefined>, _flint_fyi_core0.Rule<{
+}, "unnecessaryUseStrict", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
   readonly id: "unsafeNegations";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "preferNegatingRelation", undefined>, _flint_fyi_core0.Rule<{
+}, "preferNegatingRelation", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports attempting to delete variables with the delete operator.";
   readonly id: "variableDeletions";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noDeleteVar", undefined>, _flint_fyi_core0.Rule<{
+}, "noDeleteVar", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using the void operator.";
   readonly id: "voidOperator";
   readonly presets: readonly ["stylistic", "stylisticStrict"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "noVoid", undefined>, _flint_fyi_core0.Rule<{
+}, "noVoid", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Reports using with statements";
   readonly id: "withStatements";
   readonly presets: readonly ["javascript"];
 } & {
   readonly pluginId: string;
   readonly url: string;
-}, "withStatement", undefined>, _flint_fyi_core0.Rule<{
+}, "withStatement", undefined>, import("@flint.fyi/core").Rule<{
   readonly description: "Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.";
   readonly id: "wrapperObjects";
   readonly presets: readonly ["logical", "logicalStrict"];
@@ -2186,5 +2212,4 @@ declare const ts: _flint_fyi_core0.Plugin<_flint_fyi_core0.RuleAbout<string>, "j
   readonly url: string;
 }, "wrapperObject", undefined>]>;
 //#endregion
-export { ts };
-//# sourceMappingURL=plugin.d.ts.map
+export { ts };