@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/structuredCloneMethods.js

@@ -0,0 +1,39 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/structuredCloneMethods.ts
+function isJsonMethod(node, methodName, typeChecker) {
+	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && isGlobalDeclarationOfName(node.expression.expression, "JSON", typeChecker) && node.expression.expression.text === "JSON" && node.expression.name.text === methodName;
+}
+var structuredCloneMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.",
+		id: "structuredCloneMethods",
+		presets: ["logical"]
+	},
+	messages: { preferStructuredClone: {
+		primary: "Prefer `structuredClone()` over `JSON.parse(JSON.stringify())`.",
+		secondary: ["structuredClone is the native deep cloning API available in modern JavaScript.", "It properly handles circular references and more data types than JSON methods."],
+		suggestions: ["Replace with structuredClone()."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression(node, { sourceFile, typeChecker }) {
+			if (!isJsonMethod(node, "parse", typeChecker) || node.arguments.length !== 1) return;
+			const argument = node.arguments[0];
+			if (ts$1.isSpreadElement(argument) || !isJsonMethod(argument, "stringify", typeChecker) || argument.arguments.length !== 1) return;
+			const stringifyArgument = argument.arguments[0];
+			if (ts$1.isSpreadElement(stringifyArgument)) return;
+			context.report({
+				message: "preferStructuredClone",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { structuredCloneMethods_default as default };
+
+//# sourceMappingURL=structuredCloneMethods.js.map

package/lib/rules/symbolDescriptions.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports Symbol() calls without description arguments.";
     readonly id: "symbolDescriptions";
-    readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "missingDescription", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingDescription", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=symbolDescriptions.d.ts.map

package/lib/rules/symbolDescriptions.js

@@ -1,42 +1,32 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports Symbol() calls without description arguments.",
-        id: "symbolDescriptions",
-        preset: "stylistic",
-    },
-    messages: {
-        missingDescription: {
-            primary: "Symbols without descriptions are more difficult to debug or reason about.",
-            secondary: [
-                "Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.",
-                "While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`.",
-            ],
-            suggestions: [
-                "Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                CallExpression: (node, { sourceFile }) => {
-                    if (!ts.isIdentifier(node.expression) ||
-                        node.expression.text !== "Symbol" ||
-                        node.arguments.length) {
-                        return;
-                    }
-                    context.report({
-                        message: "missingDescription",
-                        range: {
-                            begin: node.getStart(sourceFile),
-                            end: node.getEnd(),
-                        },
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/symbolDescriptions.ts
+var symbolDescriptions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports Symbol() calls without description arguments.",
+		id: "symbolDescriptions",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { missingDescription: {
+		primary: "Symbols without descriptions are more difficult to debug or reason about.",
+		secondary: ["Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.", "While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`."],
+		suggestions: ["Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile }) => {
+			if (node.expression.kind !== SyntaxKind.Identifier || node.expression.text !== "Symbol" || node.arguments.length) return;
+			context.report({
+				message: "missingDescription",
+				range: {
+					begin: node.getStart(sourceFile),
+					end: node.getEnd()
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { symbolDescriptions_default as default };
+
 //# sourceMappingURL=symbolDescriptions.js.map

package/lib/rules/thisAliases.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports assigning `this` to a variable.";
+    readonly id: "thisAliases";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noThisAlias", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=thisAliases.d.ts.map

package/lib/rules/thisAliases.js

@@ -0,0 +1,44 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/thisAliases.ts
+var thisAliases_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports assigning `this` to a variable.",
+		id: "thisAliases",
+		presets: ["logical"]
+	},
+	messages: { noThisAlias: {
+		primary: "Assigning `this` to a variable is unnecessary with arrow functions.",
+		secondary: ["Arrow functions preserve the surrounding `this` context automatically.", "Aliasing `this` is a pre-ES2015 pattern that is no longer needed."],
+		suggestions: ["Use arrow functions to preserve the `this` context.", "Access `this` directly instead of through an alias."]
+	} },
+	setup(context) {
+		return { visitors: {
+			BinaryExpression(node, { sourceFile }) {
+				if (node.operatorToken.kind !== ts$1.SyntaxKind.EqualsToken || node.right.kind !== ts$1.SyntaxKind.ThisKeyword || !ts$1.isIdentifier(node.left)) return;
+				context.report({
+					message: "noThisAlias",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+			},
+			VariableDeclaration(node, { sourceFile }) {
+				if (node.initializer?.kind !== ts$1.SyntaxKind.ThisKeyword || !ts$1.isIdentifier(node.name)) return;
+				context.report({
+					message: "noThisAlias",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.getEnd()
+					}
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { thisAliases_default as default };
+
+//# sourceMappingURL=thisAliases.js.map

package/lib/rules/thisBeforeSuper.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `this` or `super` before calling `super()` in derived class constructors.";
+    readonly id: "thisBeforeSuper";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "thisBeforeSuper" | "superBeforeSuper", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=thisBeforeSuper.d.ts.map

package/lib/rules/thisBeforeSuper.js

@@ -0,0 +1,86 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/thisBeforeSuper.ts
+function findAllThisOrSuper(node, sourceFile, results) {
+	if (isNestedScope(node)) return;
+	if (node.kind === ts$1.SyntaxKind.ThisKeyword) {
+		results.push(node);
+		return;
+	}
+	if (node.kind === ts$1.SyntaxKind.SuperKeyword && ts$1.isPropertyAccessExpression(node.parent)) {
+		results.push(node);
+		return;
+	}
+	ts$1.forEachChild(node, (child) => {
+		findAllThisOrSuper(child, sourceFile, results);
+	});
+}
+function findAllThisOrSuperBeforePosition(node, position, sourceFile, results) {
+	if (node.getStart(sourceFile) >= position) return;
+	if (isNestedScope(node)) return;
+	if (node.kind === ts$1.SyntaxKind.ThisKeyword) {
+		results.push(node);
+		return;
+	}
+	if (node.kind === ts$1.SyntaxKind.SuperKeyword && ts$1.isPropertyAccessExpression(node.parent)) {
+		results.push(node);
+		return;
+	}
+	ts$1.forEachChild(node, (child) => {
+		findAllThisOrSuperBeforePosition(child, position, sourceFile, results);
+	});
+}
+function findFirstSuperCall(node) {
+	if (isNestedScope(node)) return;
+	if (ts$1.isCallExpression(node) && node.expression.kind === ts$1.SyntaxKind.SuperKeyword) return node;
+	return ts$1.forEachChild(node, (child) => {
+		return findFirstSuperCall(child);
+	});
+}
+function isNestedScope(node) {
+	return ts$1.isFunctionDeclaration(node) || ts$1.isFunctionExpression(node) || ts$1.isArrowFunction(node) || ts$1.isClassDeclaration(node) || ts$1.isClassExpression(node);
+}
+var thisBeforeSuper_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using `this` or `super` before calling `super()` in derived class constructors.",
+		id: "thisBeforeSuper",
+		presets: ["javascript"]
+	},
+	messages: {
+		superBeforeSuper: {
+			primary: "`super` property access is not allowed before `super()` in derived class constructors.",
+			secondary: ["Accessing `super.property` before calling `super()` throws a ReferenceError."],
+			suggestions: ["Move `super()` before any use of `super.property`."]
+		},
+		thisBeforeSuper: {
+			primary: "`this` is not allowed before `super()` in derived class constructors.",
+			secondary: ["Accessing `this` before calling `super()` throws a ReferenceError.", "The `super()` call must be the first statement that accesses the instance."],
+			suggestions: ["Move `super()` before any use of `this`."]
+		}
+	},
+	setup(context) {
+		return { visitors: { Constructor(node, { sourceFile }) {
+			if (!node.parent.heritageClauses) return;
+			if (!node.parent.heritageClauses.some((clause) => clause.token === ts$1.SyntaxKind.ExtendsKeyword) || !node.body) return;
+			const superCall = findFirstSuperCall(node.body);
+			const invalidNodes = [];
+			if (superCall) {
+				const superCallStart = superCall.getStart(sourceFile);
+				findAllThisOrSuperBeforePosition(node.body, superCallStart, sourceFile, invalidNodes);
+				for (const arg of superCall.arguments) findAllThisOrSuper(arg, sourceFile, invalidNodes);
+			} else findAllThisOrSuper(node.body, sourceFile, invalidNodes);
+			for (const invalidNode of invalidNodes) context.report({
+				message: invalidNode.kind === ts$1.SyntaxKind.ThisKeyword ? "thisBeforeSuper" : "superBeforeSuper",
+				range: {
+					begin: invalidNode.getStart(sourceFile),
+					end: invalidNode.getEnd()
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { thisBeforeSuper_default as default };
+
+//# sourceMappingURL=thisBeforeSuper.js.map

package/lib/rules/throwErrors.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports throwing values that are not `Error` objects.";
+    readonly id: "throwErrors";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "throwError" | "throwUndefined", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=throwErrors.d.ts.map

package/lib/rules/throwErrors.js

@@ -0,0 +1,61 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { declarationIncludesGlobal, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/throwErrors.ts
+function isBuiltinErrorType(type) {
+	const symbol = type.getSymbol();
+	if (symbol?.getName() !== "Error") return false;
+	return !!symbol.getDeclarations()?.some(declarationIncludesGlobal);
+}
+function isErrorType(type) {
+	if (isBuiltinErrorType(type)) return true;
+	if (type.isUnion()) return type.types.every((t) => isErrorType(t));
+	if (type.isIntersection()) return type.types.some((t) => isErrorType(t));
+	const baseTypes = type.getBaseTypes();
+	if (baseTypes) {
+		for (const baseType of baseTypes) if (isErrorType(baseType)) return true;
+	}
+	return false;
+}
+var throwErrors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports throwing values that are not `Error` objects.",
+		id: "throwErrors",
+		presets: ["logical"]
+	},
+	messages: {
+		throwError: {
+			primary: "Only `Error` objects should be thrown.",
+			secondary: ["Throwing non-`Error` values loses stack trace information.", "Error objects provide consistent behavior and debugging information."],
+			suggestions: ["Wrap the value in an `Error`: `throw new Error(value)`.", "Create a custom `Error` class for specific error types."]
+		},
+		throwUndefined: {
+			primary: "Throwing `undefined` provides no context and is hard to debug.",
+			secondary: ["Throw an `Error` to preserve stack trace and debugging details.", "If you need a custom error type, extend `Error`."],
+			suggestions: ["Throw a new `Error`: `throw new Error(\"message\")`.", "Create a custom `Error` class for specific error types."]
+		}
+	},
+	setup(context) {
+		return { visitors: { ThrowStatement(node, { sourceFile, typeChecker }) {
+			const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
+			if (tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown) || isErrorType(type)) return;
+			if (type.isUnion() ? type.types.every((t) => tsutils.isTypeFlagSet(t, ts$1.TypeFlags.Undefined)) : tsutils.isTypeFlagSet(type, ts$1.TypeFlags.Undefined)) {
+				context.report({
+					message: "throwUndefined",
+					range: getTSNodeRange(node.expression, sourceFile)
+				});
+				return;
+			}
+			context.report({
+				message: "throwError",
+				range: getTSNodeRange(node.expression, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { throwErrors_default as default };
+
+//# sourceMappingURL=throwErrors.js.map

package/lib/rules/topLevelAwaits.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports top-level await expressions in files that export values.";
+    readonly id: "topLevelAwaits";
+    readonly presets: ["logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "topLevelAwait", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=topLevelAwaits.d.ts.map

package/lib/rules/topLevelAwaits.js

@@ -0,0 +1,49 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/topLevelAwaits.ts
+function hasExportModifier(node) {
+	return !!(ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
+}
+function isInsideFunction(node) {
+	let current = node.parent;
+	while (current) {
+		if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current) || ts.isConstructorDeclaration(current) || ts.isGetAccessorDeclaration(current) || ts.isSetAccessorDeclaration(current)) return true;
+		current = current.parent;
+	}
+	return false;
+}
+var topLevelAwaits_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports top-level await expressions in files that export values.",
+		id: "topLevelAwaits",
+		presets: ["logicalStrict"]
+	},
+	messages: { topLevelAwait: {
+		primary: "Top-level await in a module file causes imports from the module to wait on the asynchronous work.",
+		secondary: ["Modules using top-level await block their dependents until the await resolves.", "This can cause unexpected delays in application startup."],
+		suggestions: ["Wrap the await in an async function that is called at the appropriate time.", "Use dynamic imports with `.then()` for lazy loading."]
+	} },
+	setup(context) {
+		let fileHasExports;
+		return { visitors: {
+			AwaitExpression(node, { sourceFile }) {
+				if (!fileHasExports || isInsideFunction(node)) return;
+				context.report({
+					message: "topLevelAwait",
+					range: {
+						begin: node.getStart(sourceFile),
+						end: node.expression.getStart(sourceFile)
+					}
+				});
+			},
+			SourceFile(node) {
+				fileHasExports = node.statements.some((statement) => hasExportModifier(statement) || statement.kind === SyntaxKind.ExportAssignment || statement.kind === SyntaxKind.ExportDeclaration);
+			}
+		} };
+	}
+});
+//#endregion
+export { topLevelAwaits_default as default };
+
+//# sourceMappingURL=topLevelAwaits.js.map

package/lib/rules/tripleSlashReferenceValidity.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports invalid triple-slash reference directives.";
+    readonly id: "tripleSlashReferenceValidity";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "invalidDirective", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=tripleSlashReferenceValidity.d.ts.map

package/lib/rules/tripleSlashReferenceValidity.js

@@ -0,0 +1,54 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/tripleSlashReferenceValidity.ts
+const referenceMatcher = /^\/\/\/\s*<\s*reference(?:\s+([\w-]+\s*=\s*"[^"]*"|[\w-]+\s*=\s*'[^']*'|[^\s/>]+))?\s*\/>/i;
+const validDirectives = new Set([
+	"lib",
+	"no-default-lib",
+	"path",
+	"types"
+]);
+var tripleSlashReferenceValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid triple-slash reference directives.",
+		id: "tripleSlashReferenceValidity",
+		presets: ["logical"]
+	},
+	messages: { invalidDirective: {
+		primary: "Invalid triple-slash reference directive format.",
+		secondary: ["Only path, types, lib, and no-default-lib directives are valid TypeScript reference types.", "Triple-slash directives with incorrect reference types don't have any affect on types."],
+		suggestions: ["Use /// <reference types=\"...\" />, /// <reference path=\"...\" />, /// <reference lib=\"...\" />, or /// <reference no-default-lib=\"true\" />."]
+	} },
+	setup(context) {
+		function checkLine(line, position) {
+			const trimmed = line.trimStart();
+			if (!trimmed.startsWith("///")) return;
+			const referenceMatch = referenceMatcher.exec(trimmed);
+			if (!referenceMatch) return;
+			const attributes = referenceMatch[1]?.trim();
+			if (attributes) {
+				const attributeMatch = /^([\w-]+)\s*=\s*["'][^"']*["']$/.exec(attributes);
+				if (attributeMatch && validDirectives.has(attributeMatch[1].toLowerCase())) return;
+			}
+			context.report({
+				message: "invalidDirective",
+				range: {
+					begin: position + line.indexOf("///"),
+					end: position + line.length
+				}
+			});
+		}
+		return { visitors: { SourceFile(node) {
+			const lines = node.getFullText().split("\n");
+			let position = 0;
+			for (const line of lines) {
+				checkLine(line, position);
+				position += line.length + 1;
+			}
+		} } };
+	}
+});
+//#endregion
+export { tripleSlashReferenceValidity_default as default };
+
+//# sourceMappingURL=tripleSlashReferenceValidity.js.map

package/lib/rules/tripleSlashReferences.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports triple-slash reference directives.";
+    readonly id: "tripleSlashReferences";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noTripleSlashReference", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=tripleSlashReferences.d.ts.map

package/lib/rules/tripleSlashReferences.js

@@ -0,0 +1,34 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/tripleSlashReferences.ts
+var tripleSlashReferences_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports triple-slash reference directives.",
+		id: "tripleSlashReferences",
+		presets: ["logical"]
+	},
+	messages: { noTripleSlashReference: {
+		primary: "Prefer ECMAScript modules and/or TSConfig settings over legacy triple-slash directives.",
+		secondary: ["ECMAScript module imports are the modern way to declare dependencies.", "Triple-slash references are only needed in specific legacy scenarios."],
+		suggestions: ["Use ECMAScript module imports instead.", "Configure tsconfig.json to include type definitions."]
+	} },
+	setup(context) {
+		return { visitors: { SourceFile(node) {
+			for (const reference of [
+				...node.referencedFiles,
+				...node.typeReferenceDirectives,
+				...node.libReferenceDirectives
+			]) context.report({
+				message: "noTripleSlashReference",
+				range: {
+					begin: reference.pos,
+					end: reference.end
+				}
+			});
+		} } };
+	}
+});
+//#endregion
+export { tripleSlashReferences_default as default };
+
+//# sourceMappingURL=tripleSlashReferences.js.map

package/lib/rules/tsComments.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports problematic TypeScript comment directives or requires descriptions after directives.";
+    readonly id: "tsComments";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "descriptionNotMatchPattern" | "directiveComment" | "preferExpectError" | "requiresDescription", {
+    allowTsExpectError: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"allow-with-description">, z.ZodObject<{
+        descriptionFormat: z.ZodString;
+    }, z.core.$strip>]>>;
+    allowTsIgnore: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"allow-with-description">, z.ZodObject<{
+        descriptionFormat: z.ZodString;
+    }, z.core.$strip>]>>;
+    allowTsNocheck: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"allow-with-description">, z.ZodObject<{
+        descriptionFormat: z.ZodString;
+    }, z.core.$strip>]>>;
+    minimumDescriptionLength: z.ZodDefault<z.ZodNumber>;
+}>;
+export default _default;
+//# sourceMappingURL=tsComments.d.ts.map