eslint-plugin-wyrm 0.0.11 → 0.0.13

package/dist/rules/inner-as-const.mjs

@@ -0,0 +1,70 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/inner-as-const.ts
+const { name } = path.parse(import.meta.filename);
+var inner_as_const_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce setting `as const` on the outermost object/array literal only",
+			strict: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			noInnerAsConstObject: "Only set `as const` on the outermost object",
+			noInnerAsConstArray: "Only set `as const` on the outermost array"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ArrayExpression(node) {
+				for (const elt of node.elements) {
+					if (!elt) continue;
+					const maybeExpr = getAsConstExpr(elt);
+					if (!maybeExpr.some) continue;
+					const expr = maybeExpr.value;
+					context.report({
+						node: elt,
+						messageId: "noInnerAsConstArray",
+						*fix(fixer) {
+							yield fixer.replaceText(elt, context.sourceCode.getText(expr));
+							if (getAsConstExpr(node.parent).some) return;
+							yield fixer.insertTextAfter(node, " as const");
+						}
+					});
+				}
+			},
+			ObjectExpression(node) {
+				for (const prop of node.properties) {
+					if (prop.type === AST_NODE_TYPES.SpreadElement) continue;
+					const maybeExpr = getAsConstExpr(prop.value);
+					if (!maybeExpr.some) continue;
+					const expr = maybeExpr.value;
+					context.report({
+						node: prop,
+						messageId: "noInnerAsConstObject",
+						*fix(fixer) {
+							yield fixer.replaceText(prop.value, context.sourceCode.getText(expr));
+							if (getAsConstExpr(node.parent).some) return;
+							yield fixer.insertTextAfter(node, " as const");
+						}
+					});
+				}
+			}
+		};
+	}
+});
+function getAsConstExpr(node) {
+	if (node.type !== AST_NODE_TYPES.TSAsExpression) return None;
+	if (node.typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) return None;
+	if (node.typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier) return None;
+	if (node.typeAnnotation.typeName.name !== "const") return None;
+	return Some(node.expression);
+}
+//#endregion
+export { inner_as_const_default as default };

package/dist/rules/jsx-tostring.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/jsx-tostring.d.ts
+declare const _default: ESLintUtils.RuleModule<"noToString", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/jsx-tostring.mjs

@@ -0,0 +1,120 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some, getFirstOption } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+//#region lib/rules/jsx-tostring.ts
+const { name } = path.parse(import.meta.filename);
+var jsx_tostring_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid calling `.toString()` inside JSX expressions containers",
+			strict: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noToString: "Calling `.toString()` is unnecessary here" }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		return { JSXExpressionContainer(node) {
+			checkJsxExpression(node);
+		} };
+		function checkJsxExpression(container) {
+			const { expression } = container;
+			if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) return;
+			const maybeObj = getToString(expression);
+			if (!maybeObj.some) return;
+			const obj = maybeObj.value;
+			const objType = getServices().getTypeAtLocation(obj);
+			const { parent } = container;
+			if (parent.type === AST_NODE_TYPES.JSXFragment) {
+				context.report({
+					node: expression,
+					messageId: "noToString",
+					fix(fixer) {
+						const txt = context.sourceCode.getText(obj);
+						return fixer.replaceText(expression, txt);
+					}
+				});
+				return;
+			}
+			if (parent.type !== AST_NODE_TYPES.JSXElement) return;
+			const { openingElement } = parent;
+			if (openingElement.name.type === AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(openingElement.name.name)) {
+				context.report({
+					node: expression,
+					messageId: "noToString",
+					fix(fixer) {
+						const txt = context.sourceCode.getText(obj);
+						return fixer.replaceText(expression, txt);
+					}
+				});
+				return;
+			}
+			const maybeChildrenType = getChildrenPropTypeFromComponentType(getServices().getTypeAtLocation(openingElement.name));
+			if (!maybeChildrenType.some) return;
+			const childrenType = maybeChildrenType.value;
+			if (!isAssignableTo(objType, childrenType)) return;
+			context.report({
+				node: expression,
+				messageId: "noToString",
+				fix(fixer) {
+					const txt = context.sourceCode.getText(obj);
+					return fixer.replaceText(expression, txt);
+				}
+			});
+		}
+		function getChildrenPropTypeFromComponentType(type) {
+			return getFirstOption([getChildrenTypeFromSignatures(type.getCallSignatures()), getChildrenTypeFromSignatures(type.getConstructSignatures())]);
+		}
+		function getChildrenTypeFromSignatures(signatures) {
+			for (const signature of signatures) {
+				const maybeChildrenType = getChildrenTypeFromSignature(signature);
+				if (!maybeChildrenType.some) continue;
+				return maybeChildrenType;
+			}
+			return None;
+		}
+		function getChildrenTypeFromSignature(signature) {
+			const [param] = signature.getParameters();
+			if (!param) return None;
+			const paramType = getValueTypeFromSymbol(param);
+			/* v8 ignore if -- @preserve */
+			if (!paramType) return None;
+			const childrenProp = paramType.getProperty("children");
+			if (!childrenProp) return None;
+			const childrenType = getValueTypeFromSymbol(childrenProp);
+			if (childrenType) return Some(childrenType);
+			return None;
+		}
+		function getValueTypeFromSymbol(symbol) {
+			if (!symbol.valueDeclaration) return null;
+			return getChecker().getTypeOfSymbolAtLocation(symbol, symbol.valueDeclaration);
+		}
+		function isAssignableTo(source, target) {
+			return getChecker().isTypeAssignableTo(source, getChecker().getWidenedType(target));
+		}
+	}
+});
+function getToString(expr) {
+	if (expr.type !== AST_NODE_TYPES.CallExpression) return None;
+	if (expr.callee.type !== AST_NODE_TYPES.MemberExpression) return None;
+	if (expr.callee.property.type !== AST_NODE_TYPES.Identifier) return None;
+	if (expr.callee.property.name !== "toString") return None;
+	return Some(expr.callee.object);
+}
+//#endregion
+export { jsx_tostring_default as default };

package/dist/rules/literal-destructuring.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/literal-destructuring.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"uselessSpreadElement" | "uselessSpreadProperty" | "usePlainDeclaration", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/literal-destructuring.mjs

@@ -0,0 +1,102 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/literal-destructuring.ts
+const { name } = path.parse(import.meta.filename);
+var literal_destructuring_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid variable declaration by destructuring object or array literals",
+			strict: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			uselessSpreadElement: "Remove this spread element from the array literal, it is most likely useless since its value is never read.",
+			uselessSpreadProperty: "Remove this spread property from the object literal, it is most likely useless since its value is never read.",
+			usePlainDeclaration: "Use a plain variable declaration instead of destructuring a literal"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { VariableDeclarator(node) {
+			if (!node.init) return;
+			if (node.id.type === AST_NODE_TYPES.ArrayPattern && node.init.type === AST_NODE_TYPES.ArrayExpression) {
+				checkArrayDecl(node, node.id, node.init);
+				return;
+			}
+			if (node.id.type === AST_NODE_TYPES.ObjectPattern && node.init.type === AST_NODE_TYPES.ObjectExpression) checkObjectDecl(node, node.id, node.init);
+		} };
+		function checkArrayDecl(decl, id, init) {
+			const spreadElement = init.elements.find((elt) => elt?.type === AST_NODE_TYPES.SpreadElement);
+			if (spreadElement) {
+				const idx = init.elements.indexOf(spreadElement);
+				if (idx >= id.elements.length) context.report({
+					node: spreadElement,
+					messageId: "uselessSpreadElement",
+					*fix(fixer) {
+						yield fixer.remove(spreadElement);
+						const commaToken = context.sourceCode.getTokenAfter(spreadElement);
+						if (idx === 0 && commaToken?.type === AST_TOKEN_TYPES.Punctuator && commaToken.value === ",") yield fixer.remove(commaToken);
+					}
+				});
+				return;
+			}
+			if (!id.elements.every((elt) => elt?.type === AST_NODE_TYPES.Identifier)) return;
+			if (!init.elements.every((elt) => elt?.type !== AST_NODE_TYPES.SpreadElement)) return;
+			const entries = id.elements.map((ident, i) => [ident.name, init.elements.filter((elt) => elt?.type !== AST_NODE_TYPES.SpreadElement).at(i)]);
+			context.report({
+				node: decl,
+				messageId: "usePlainDeclaration",
+				fix(fixer) {
+					const txt = entries.map(([key, value]) => {
+						return `${key} = ${value ? context.sourceCode.getText(value) : "undefined"}`;
+					}).join(", ");
+					return fixer.replaceText(decl, txt);
+				}
+			});
+		}
+		function checkObjectDecl(decl, id, init) {
+			if (!id.properties.every((prop) => prop.type === AST_NODE_TYPES.Property)) return;
+			if (id.properties.some((prop) => prop.computed)) return;
+			const patternKeys = id.properties.map((prop) => prop.key);
+			if (!patternKeys.every((key) => key.type === AST_NODE_TYPES.Identifier)) return;
+			const patternNames = patternKeys.map((key) => key.name);
+			for (const initProp of init.properties) {
+				if (initProp.type === AST_NODE_TYPES.Property) {
+					if (initProp.computed) return;
+					continue;
+				}
+				const idx = init.properties.indexOf(initProp);
+				const subsequentPropertyNames = new Set(init.properties.slice(idx).filter((prop) => prop.type === AST_NODE_TYPES.Property).map((prop) => prop.key).filter((key) => key.type === AST_NODE_TYPES.Identifier).map((key) => key.name));
+				if (patternNames.every((patternName) => subsequentPropertyNames.has(patternName))) context.report({
+					node: initProp,
+					messageId: "uselessSpreadProperty",
+					*fix(fixer) {
+						yield fixer.remove(initProp);
+						const commaToken = context.sourceCode.getTokenAfter(initProp);
+						if (idx === 0 && commaToken?.type === AST_TOKEN_TYPES.Punctuator && commaToken.value === ",") yield fixer.remove(commaToken);
+					}
+				});
+				return;
+			}
+			const initMap = new Map(init.properties.filter((prop) => prop.type === AST_NODE_TYPES.Property).map((prop) => [prop.key, prop.value]).filter((entry) => entry[0].type === AST_NODE_TYPES.Identifier).map(([key, value]) => [key.name, value]));
+			const entries = patternNames.map((patternName) => [patternName, initMap.get(patternName)]);
+			if (!entries.every((entry) => entry[1] !== void 0)) return;
+			context.report({
+				node: decl,
+				messageId: "usePlainDeclaration",
+				fix(fixer) {
+					const txt = entries.map(([key, value]) => {
+						return `${key} = ${context.sourceCode.getText(value)}`;
+					}).join(", ");
+					return fixer.replaceText(decl, txt);
+				}
+			});
+		}
+	}
+});
+//#endregion
+export { literal_destructuring_default as default };

package/dist/rules/named-export-with-side-effects.d.mts

@@ -1,10 +1,10 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/named-export-with-side-effects.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"namedExportWithSideEffects", [{
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"namedExportWithSideEffects", [{
   strict: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener> & {
+}], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/named-export-with-side-effects.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/named-export-with-side-effects.ts
 const { name } = path.parse(import.meta.filename);
 const DEFAULT_STRICT = false;
@@ -69,6 +68,5 @@ function isSideEffect(stmt, strict) {
 		default: return false;
 	}
 }
-
 //#endregion
-export { named_export_with_side_effects_default as default };
+export { named_export_with_side_effects_default as default };

package/dist/rules/nested-reduce.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/nested-reduce.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noNestedReduce", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/nested-reduce.mjs

@@ -0,0 +1,46 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/nested-reduce.ts
+const { name } = path.parse(import.meta.filename);
+var nested_reduce_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid nested `reduce` calls",
+			strict: true
+		},
+		schema: [],
+		messages: { noNestedReduce: "Refactor to avoid nesting `reduce` calls." }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { CallExpression(node) {
+			if (!isReduceCall(node)) return;
+			if (!isInsideReduceCall(node)) return;
+			context.report({
+				node: node.callee,
+				messageId: "noNestedReduce"
+			});
+		} };
+	}
+});
+function isReduceCall(expr) {
+	if (expr.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (expr.callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	return expr.callee.property.name === "reduce";
+}
+function isInsideReduceCall(node) {
+	if (!node.parent) return false;
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.FunctionDeclaration: return false;
+		case AST_NODE_TYPES.CallExpression:
+			if (isReduceCall(node.parent)) return true;
+			break;
+		default: break;
+	}
+	return isInsideReduceCall(node.parent);
+}
+//#endregion
+export { nested_reduce_default as default };

package/dist/rules/nested-try-catch.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/nested-try-catch.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noNestedTryCatch", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/nested-try-catch.mjs

@@ -0,0 +1,37 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/nested-try-catch.ts
+const { name } = path.parse(import.meta.filename);
+var nested_try_catch_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid nested try/catch statements",
+			strict: true
+		},
+		schema: [],
+		messages: { noNestedTryCatch: "Refactor to avoid nesting try/catch statements." }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { TryStatement(node) {
+			if (node.parent.type !== AST_NODE_TYPES.BlockStatement) return;
+			switch (node.parent.parent.type) {
+				case AST_NODE_TYPES.TryStatement:
+				case AST_NODE_TYPES.CatchClause: {
+					const token = context.sourceCode.getFirstToken(node);
+					context.report({
+						node: token ?? node,
+						messageId: "noNestedTryCatch"
+					});
+					break;
+				}
+				default: break;
+			}
+		} };
+	}
+});
+//#endregion
+export { nested_try_catch_default as default };

package/dist/rules/no-commented-out-comment.d.mts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-commented-out-comment.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"commentedOutComment", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"commentedOutComment", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-commented-out-comment.mjs

@@ -1,6 +1,5 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
-
 //#region lib/rules/no-commented-out-comment.ts
 const { name } = path.parse(import.meta.filename);
 var no_commented_out_comment_default = createRule({
@@ -28,6 +27,5 @@ var no_commented_out_comment_default = createRule({
 		}
 	}
 });
-
 //#endregion
-export { no_commented_out_comment_default as default };
+export { no_commented_out_comment_default as default };

package/dist/rules/no-constant-template-expression.mjs

@@ -1,8 +1,7 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils, TSESLint } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
+import * as ts$1 from "typescript";
 //#region lib/rules/no-constant-template-expression.ts
 /**
 * @fileoverview
@@ -56,6 +55,7 @@ var no_constant_template_expression_default = createRule({
 					const def = defs.at(-1);
 					if (def?.parent?.type === AST_NODE_TYPES.VariableDeclaration && def.parent.parent.type === AST_NODE_TYPES.ExportNamedDeclaration) return;
 					if (def?.type !== TSESLint.Scope.DefinitionType.Variable) return;
+					if (isNonAlphabeticStringLiteral(def.node)) return;
 				}
 			}
 			const services = ESLintUtils.getParserServices(context);
@@ -64,7 +64,7 @@ var no_constant_template_expression_default = createRule({
 			if (value === null) return;
 			if (value.length >= options.minAllowedLength) return;
 			const sym = services.getSymbolAtLocation(expr);
-			if (sym && sym.getFlags() & ts.SymbolFlags.EnumMember && !quasis.some((quasi) => quasi.value.cooked)) return;
+			if (sym && sym.getFlags() & ts$1.SymbolFlags.EnumMember && !quasis.some((quasi) => quasi.value.cooked)) return;
 			context.report({
 				node: expr,
 				messageId: "noConstantTemplateExpression",
@@ -91,7 +91,8 @@ var no_constant_template_expression_default = createRule({
 		}
 		return { TemplateLiteral(node) {
 			const { expressions, quasis } = node;
-			if (quasis.some((quasi) => quasi.value.cooked.includes(" "))) return;
+			if (quasis.some((quasi) => quasi.value.cooked?.includes(" "))) return;
+			if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) return;
 			const scope = context.sourceCode.getScope(node);
 			for (const expr of expressions) checkExpression(expr, quasis, scope);
 		} };
@@ -103,6 +104,8 @@ function getLiteralValue(type, checker) {
 	if (type === checker.getFalseType()) return "false";
 	return null;
 }
-
+function isNonAlphabeticStringLiteral(node) {
+	return node.init?.type === AST_NODE_TYPES.Literal && typeof node.init.value === "string" && /[^a-zA-Z]/u.test(node.init.value);
+}
 //#endregion
-export { no_constant_template_expression_default as default };
+export { no_constant_template_expression_default as default };

package/dist/rules/no-constructed-error-cause.d.mts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-constructed-error-cause.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"noConstructedErrorCause", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noConstructedErrorCause", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-constructed-error-cause.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-constructed-error-cause.ts
 /**
 * @fileoverview
@@ -72,6 +71,5 @@ var no_constructed_error_cause_default = createRule({
 		}
 	}
 });
-
 //#endregion
-export { no_constructed_error_cause_default as default };
+export { no_constructed_error_cause_default as default };

package/dist/rules/no-convoluted-boolean-expressions.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-convoluted-boolean-expressions.d.ts
+declare const _default: ESLintUtils.RuleModule<"noConvolutedLogicalExpression", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };