eslint-plugin-typefest 1.0.4 → 1.0.5

package/dist/plugin.cjs

@@ -34,13 +34,13 @@ __export(plugin_exports, {
 });
 module.exports = __toCommonJS(plugin_exports);
 var import_parser3 = __toESM(require("@typescript-eslint/parser"), 1);
-var import_ts_extras37 = require("ts-extras");
+var import_ts_extras39 = require("ts-extras");
 
 // package.json
 var package_default = {
   $schema: "https://www.schemastore.org/package.json",
   name: "eslint-plugin-typefest",
-  version: "1.0.4",
+  version: "1.0.5",
   private: false,
   description: "ESLint rules for adopting type-fest and ts-extras conventions.",
   keywords: [
@@ -61,12 +61,12 @@ var package_default = {
     url: "git+https://github.com/Nick2bad4u/eslint-plugin-typefest.git"
   },
   license: "MIT",
-  author: "Nick2bad4u <20943337+Nick2bad4u@users.noreply.github.com> (https://nick2bad4u.github.io/eslint-plugin-typefest)",
+  author: "Nick2bad4u <20943337+Nick2bad4u@users.noreply.github.com> (https://github.com/Nick2bad4u)",
   contributors: [
     {
       name: "Nick2bad4u",
       email: "20943337+Nick2bad4u@users.noreply.github.com",
-      url: "https://nick2bad4u.github.io/eslint-plugin-typefest"
+      url: "https://github.com/Nick2bad4u"
     }
   ],
   sideEffects: false,
@@ -115,6 +115,8 @@ var package_default = {
     "build:clean": `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
     "build:eslint-inspector": 'npx -y @eslint/config-inspector@1.4.2 build --outDir "docs/docusaurus/static/eslint-inspector" --base "/eslint-plugin-typefest/eslint-inspector/"',
     "build:eslint-inspector:local": "npx @eslint/config-inspector",
+    "build:stylelint-inspector": 'npx -y stylelint-config-inspector@latest build --outDir "docs/docusaurus/static/stylelint-inspector" --base "/eslint-plugin-typefest/stylelint-inspector/"',
+    "build:stylelint-inspector:local": "npx stylelint-config-inspector@latest",
     "build:types:cjs": `node -e "require('node:fs').copyFileSync('dist/plugin.d.ts','dist/plugin.d.cts')"`,
     "changelog:generate": "git-cliff --config cliff.toml --output CHANGELOG.md",
     "changelog:preview": "git-cliff --config cliff.toml --unreleased",
@@ -146,8 +148,10 @@ var package_default = {
     "docs:build": "npm run --workspace docs/docusaurus build",
     "docs:build:local": "npm run --workspace docs/docusaurus build:local",
     "docs:check-links": "npm run docs:api && node ./scripts/check-doc-links.mjs",
+    "docs:devtools:metadata": "node scripts/generate-devtools-workspace-metadata.mjs",
     "docs:serve": "npm run --workspace docs/docusaurus serve",
     "docs:start": "npm run --workspace docs/docusaurus start",
+    "docs:start:devtools": "npm run docs:devtools:metadata && npm run docs:api:local && npm run --workspace docs/docusaurus start:devtools",
     "docs:toc": "remark docs --use remark-toc --output",
     "docs:typecheck": "npm run --workspace docs/docusaurus typecheck",
     "docs:typedoc": "npm run --workspace docs/docusaurus docs:api",
@@ -209,7 +213,7 @@ var package_default = {
     "open:coverage": "open-cli coverage/index.html",
     prepublishOnly: "npm run release:check",
     "release:check": "npm run release:verify",
-    "release:verify": "npm run build && npm run lint && npm run typecheck && npm run test && npm run sync:readme-rules-table && npm run sync:presets-rules-matrix && npm run docs:check-links && npm pack --dry-run",
+    "release:verify": "cross-env NODE_OPTIONS= npm run build && cross-env NODE_OPTIONS= npm run lint && cross-env NODE_OPTIONS= npm run typecheck && cross-env NODE_OPTIONS= VITEST_TYPECHECK=false npm run test && cross-env NODE_OPTIONS= npm run sync:readme-rules-table && cross-env NODE_OPTIONS= npm run sync:presets-rules-matrix && cross-env NODE_OPTIONS= npm run docs:check-links && cross-env NODE_OPTIONS= npm pack --dry-run",
     "remark:fix": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail --quiet --output -- "*.{md,mdx}" "docs/**/*.{md,mdx}"',
     "remark:test-config": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail "README.md"',
     "sync:node-version-files": "node scripts/sync-node-version-files.mjs",
@@ -254,7 +258,7 @@ var package_default = {
     "@typescript-eslint/type-utils": "^8.57.1",
     "@typescript-eslint/utils": "^8.57.1",
     "ts-extras": "^0.17.0",
-    "type-fest": "^5.4.4"
+    "type-fest": "^5.5.0"
   },
   devDependencies: {
     "@arethetypeswrong/cli": "^0.18.2",
@@ -338,7 +342,7 @@ var package_default = {
     "eslint-plugin-depend": "^1.5.0",
     "eslint-plugin-eslint-plugin": "^7.3.2",
     "eslint-plugin-etc": "^2.0.3",
-    "eslint-plugin-etc-misc": "^1.0.2",
+    "eslint-plugin-etc-misc": "^1.0.3",
     "eslint-plugin-file-progress-2": "^3.4.3",
     "eslint-plugin-html": "^8.1.4",
     "eslint-plugin-import-x": "^4.16.2",
@@ -361,7 +365,7 @@ var package_default = {
     "eslint-plugin-no-use-extend-native": "^0.7.2",
     "eslint-plugin-node-dependencies": "^2.2.0",
     "eslint-plugin-package-json": "^0.91.0",
-    "eslint-plugin-perfectionist": "^5.6.0",
+    "eslint-plugin-perfectionist": "^5.7.0",
     "eslint-plugin-prefer-arrow": "^1.2.3",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",
@@ -371,12 +375,12 @@ var package_default = {
     "eslint-plugin-security": "^4.0.0",
     "eslint-plugin-sonarjs": "^4.0.2",
     "eslint-plugin-sort-class-members": "^1.21.0",
-    "eslint-plugin-testing-library": "^7.16.0",
+    "eslint-plugin-testing-library": "^7.16.1",
     "eslint-plugin-toml": "^1.3.1",
     "eslint-plugin-total-functions": "^7.1.0",
     "eslint-plugin-tsdoc": "^0.5.2",
     "eslint-plugin-tsdoc-require-2": "^1.0.5",
-    "eslint-plugin-typefest": "^1.0.3",
+    "eslint-plugin-typefest": "^1.0.4",
     "eslint-plugin-undefined-css-classes": "^0.1.5",
     "eslint-plugin-unicorn": "^63.0.0",
     "eslint-plugin-unused-imports": "^4.4.1",
@@ -390,11 +394,11 @@ var package_default = {
     htmlhint: "^1.9.2",
     jscpd: "^4.0.8",
     "jsonc-eslint-parser": "^3.1.0",
-    knip: "^5.87.0",
+    knip: "^5.88.1",
     leasot: "^14.4.0",
     madge: "^8.0.0",
     "markdown-link-check": "^3.14.2",
-    "npm-check-updates": "^19.6.3",
+    "npm-check-updates": "^19.6.5",
     "npm-package-json-lint": "^9.1.0",
     picocolors: "^1.1.1",
     postcss: "^8.5.8",
@@ -537,13 +541,14 @@ var package_default = {
     secretlint: "^11.3.1",
     sloc: "^0.3.2",
     "sort-package-json": "^3.6.1",
-    stylelint: "^17.4.0",
+    stylelint: "^17.5.0",
     "stylelint-actions-formatters": "^16.3.1",
     "stylelint-checkstyle-formatter": "^0.1.2",
     "stylelint-codeframe-formatter": "^1.2.0",
     "stylelint-config-alphabetical-order": "^2.0.0",
     "stylelint-config-idiomatic-order": "^10.0.0",
-    "stylelint-config-recess-order": "^7.6.1",
+    "stylelint-config-inspector": "^2.0.1",
+    "stylelint-config-recess-order": "^7.7.0",
     "stylelint-config-recommended": "^18.0.0",
     "stylelint-config-sass-guidelines": "^13.0.0",
     "stylelint-config-standard": "^40.0.0",
@@ -565,7 +570,7 @@ var package_default = {
     "stylelint-no-unresolved-module": "^2.5.2",
     "stylelint-no-unsupported-browser-features": "^8.1.1",
     "stylelint-order": "^8.1.1",
-    "stylelint-plugin-defensive-css": "^2.6.0",
+    "stylelint-plugin-defensive-css": "^2.8.0",
     "stylelint-plugin-logical-css": "^2.0.2",
     "stylelint-plugin-use-baseline": "^1.2.7",
     "stylelint-prettier": "^5.0.3",
@@ -581,7 +586,7 @@ var package_default = {
     "typescript-eslint": "^8.57.1",
     typesync: "^0.14.3",
     vfile: "^6.0.3",
-    vite: "^8.0.0",
+    vite: "^8.0.1",
     "vite-tsconfig-paths": "^6.1.1",
     vitest: "^4.1.0",
     "yaml-eslint-parser": "^2.0.0",
@@ -591,7 +596,7 @@ var package_default = {
     eslint: "^9.0.0 || ^10.0.3",
     typescript: ">=5.0.0"
   },
-  packageManager: "npm@11.11.1",
+  packageManager: "npm@11.12.0",
   engines: {
     node: ">=22.0.0"
   },
@@ -1167,6 +1172,13 @@ var evaluateIsArrayLikeType = ({ candidateType, checker, resolutionCache, seenTy
   resolutionCache.set(candidateType, false);
   return false;
 };
+var isArrayLikeType = (checker, type, unionMatchMode = "some") => evaluateIsArrayLikeType({
+  candidateType: type,
+  checker,
+  resolutionCache: /* @__PURE__ */ new Map(),
+  seenTypes: /* @__PURE__ */ new Set(),
+  unionMatchMode
+});
 var getArrayLikeExpressionPrefilterResult = (expression) => {
   if (expression.type === "ArrayExpression") {
     return true;
@@ -2324,7 +2336,16 @@ var orderedRuleNames = [
   "prefer-type-fest-unwrap-tagged",
   "prefer-type-fest-value-of",
   "prefer-type-fest-writable",
-  "prefer-type-fest-writable-deep"
+  "prefer-type-fest-writable-deep",
+  "prefer-type-fest-and-all",
+  "prefer-type-fest-array-length",
+  "prefer-type-fest-optional",
+  "prefer-type-fest-or-all",
+  "prefer-type-fest-union-member",
+  "prefer-type-fest-conditional-pick-deep",
+  "prefer-type-fest-union-to-tuple",
+  "prefer-type-fest-less-than",
+  "prefer-type-fest-less-than-or-equal"
 ];
 var toRuleCatalogId = (ruleNumber) => `R${String(ruleNumber).padStart(3, "0")}`;
 var isTypefestRuleNamePattern2 = (ruleName) => ruleName.startsWith("prefer-");
@@ -6609,6 +6630,140 @@ var preferTypeFestAbstractConstructorRule = createTypedRule({
 });
 var prefer_type_fest_abstract_constructor_default = preferTypeFestAbstractConstructorRule;
 
+// dist/rules/prefer-type-fest-and-all.js
+var ALL_EXTEND_TYPE_NAME = "AllExtend";
+var AND_ALL_TYPE_NAME = "AndAll";
+var isTrueLiteralType = (node) => node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === true;
+var preferTypeFestAndAllRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const allExtendLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, ALL_EXTEND_TYPE_NAME);
+    const typeFestNamespaceImportNames = collectNamespaceImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const getAllExtendTupleArgumentText = (typeReference) => {
+      const typeArguments = typeReference.typeArguments?.params ?? [];
+      const [tupleArgument, comparedType] = typeArguments;
+      if (!tupleArgument || !comparedType || !isTrueLiteralType(comparedType)) {
+        return null;
+      }
+      if (typeArguments.length !== 2) {
+        return null;
+      }
+      return context.sourceCode.getText(tupleArgument);
+    };
+    const reportIfAllExtendEquivalent = (node) => {
+      const tupleArgumentText = getAllExtendTupleArgumentText(node);
+      if (tupleArgumentText === null || tupleArgumentText.trim().length === 0) {
+        return;
+      }
+      const fix = createSafeTypeNodeTextReplacementFix(node, AND_ALL_TYPE_NAME, `${AND_ALL_TYPE_NAME}<${tupleArgumentText}>`, typeFestDirectImports);
+      reportWithOptionalFix({
+        context,
+        fix,
+        messageId: "preferAndAll",
+        node
+      });
+    };
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(typeReference) {
+        if (typeReference.typeName.type !== "Identifier" || !setContainsValue(allExtendLocalNames, typeReference.typeName.name)) {
+          return;
+        }
+        reportIfAllExtendEquivalent(typeReference);
+      },
+      'TSTypeReference[typeName.type="TSQualifiedName"]'(typeReference) {
+        if (typeReference.typeName.type !== "TSQualifiedName") {
+          return;
+        }
+        if (typeReference.typeName.left.type !== "Identifier" || !setContainsValue(typeFestNamespaceImportNames, typeReference.typeName.left.name) || typeReference.typeName.right.type !== "Identifier" || typeReference.typeName.right.name !== ALL_EXTEND_TYPE_NAME) {
+          return;
+        }
+        reportIfAllExtendEquivalent(typeReference);
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest AndAll over `AllExtend<TTuple, true>` boolean-tuple checks.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-and-all"
+    },
+    fixable: "code",
+    messages: {
+      preferAndAll: "Prefer `AndAll<TTuple>` from type-fest over `AllExtend<TTuple, true>` for boolean-tuple conjunction checks."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-and-all"
+});
+var prefer_type_fest_and_all_default = preferTypeFestAndAllRule;
+
+// dist/rules/prefer-type-fest-array-length.js
+var ARRAY_LENGTH_TYPE_NAME = "ArrayLength";
+var isLengthIndexType = (node) => node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === "length";
+var preferTypeFestArrayLengthRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const { checker, parserServices } = getTypedRuleServices(context);
+    return {
+      TSIndexedAccessType(node) {
+        if (!isLengthIndexType(node.indexType)) {
+          return;
+        }
+        const objectType = getConstrainedTypeAtLocationWithFallback(checker, node.objectType, parserServices, "prefer-type-fest-array-length-type-resolution-failed");
+        if (!objectType || !isArrayLikeType(checker, objectType, "every")) {
+          return;
+        }
+        const objectTypeText = context.sourceCode.getText(node.objectType);
+        if (objectTypeText.trim().length === 0) {
+          return;
+        }
+        const fix = createSafeTypeNodeTextReplacementFix(node, ARRAY_LENGTH_TYPE_NAME, `${ARRAY_LENGTH_TYPE_NAME}<${objectTypeText}>`, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix,
+          messageId: "preferArrayLength",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: 'require TypeFest ArrayLength over array and tuple `T["length"]` type queries.',
+      frozen: false,
+      recommended: false,
+      requiresTypeChecking: true,
+      typefestConfigs: [
+        "typefest.configs.recommended-type-checked",
+        "typefest.configs.strict",
+        "typefest.configs.all"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-array-length"
+    },
+    fixable: "code",
+    messages: {
+      preferArrayLength: 'Prefer `ArrayLength<T>` from type-fest over array and tuple `T["length"]` type queries.'
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-array-length"
+});
+var prefer_type_fest_array_length_default = preferTypeFestArrayLengthRule;
+
 // dist/_internal/type-reference-node.js
 var isIdentifierTypeReference = (node, identifierName) => node.type === "TSTypeReference" && node.typeName.type === "Identifier" && node.typeName.name === identifierName;
 
@@ -6766,6 +6921,65 @@ var preferTypeFestAsyncReturnTypeRule = createTypedRule({
 });
 var prefer_type_fest_async_return_type_default = preferTypeFestAsyncReturnTypeRule;
 
+// dist/rules/prefer-type-fest-conditional-pick-deep.js
+var conditionalPickDeepAliasReplacements = {
+  PickDeepByType: "ConditionalPickDeep",
+  PickDeepByTypes: "ConditionalPickDeep"
+};
+var preferTypeFestConditionalPickDeepRule = createTypedRule({
+  create(context) {
+    const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, conditionalPickDeepAliasReplacements);
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(node) {
+        if (node.typeName.type !== "Identifier") {
+          return;
+        }
+        const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
+        if (!importedAliasMatch) {
+          return;
+        }
+        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          data: {
+            alias: importedAliasMatch.importedName,
+            replacement: importedAliasMatch.replacementName
+          },
+          fix: aliasReplacementFix,
+          messageId: "preferConditionalPickDeep",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest ConditionalPickDeep over imported aliases such as PickDeepByTypes.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-conditional-pick-deep"
+    },
+    fixable: "code",
+    messages: {
+      preferConditionalPickDeep: "Prefer `{{replacement}}` from type-fest for deep conditional property filtering instead of legacy alias `{{alias}}`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-conditional-pick-deep"
+});
+var prefer_type_fest_conditional_pick_deep_default = preferTypeFestConditionalPickDeepRule;
+
 // dist/rules/prefer-type-fest-conditional-pick.js
 var conditionalPickAliasReplacements = {
   PickByTypes: "ConditionalPick"
@@ -7455,6 +7669,236 @@ var preferTypeFestKeysOfUnionRule = createTypedRule({
 });
 var prefer_type_fest_keys_of_union_default = preferTypeFestKeysOfUnionRule;
 
+// dist/rules/prefer-type-fest-less-than-or-equal.js
+var GREATER_THAN_TYPE_NAME = "GreaterThan";
+var LESS_THAN_OR_EQUAL_TYPE_NAME = "LessThanOrEqual";
+var isLiteralBooleanType = (node, expectedBooleanValue) => node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === expectedBooleanValue;
+var isFalseLiteralType = (node) => isLiteralBooleanType(node, false);
+var isTrueLiteralType2 = (node) => isLiteralBooleanType(node, true);
+var preferTypeFestLessThanOrEqualRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const greaterThanLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, GREATER_THAN_TYPE_NAME);
+    const typeFestNamespaceImportNames = collectNamespaceImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const getComparatorTypeArgumentTexts = (typeReference) => {
+      const typeArguments = typeReference.typeArguments?.params ?? [];
+      const [leftType, rightType] = typeArguments;
+      if (!leftType || !rightType || typeArguments.length !== 2) {
+        return null;
+      }
+      return {
+        leftTypeText: context.sourceCode.getText(leftType),
+        rightTypeText: context.sourceCode.getText(rightType)
+      };
+    };
+    const isGreaterThanTypeReference = (typeReference) => {
+      if (typeReference.typeName.type === "Identifier") {
+        return setContainsValue(greaterThanLocalNames, typeReference.typeName.name);
+      }
+      if (typeReference.typeName.type !== "TSQualifiedName") {
+        return false;
+      }
+      return typeReference.typeName.left.type === "Identifier" && setContainsValue(typeFestNamespaceImportNames, typeReference.typeName.left.name) && typeReference.typeName.right.type === "Identifier" && typeReference.typeName.right.name === GREATER_THAN_TYPE_NAME;
+    };
+    const getComparatorTypeArgumentTextsFromTypeNode = (typeNode) => {
+      if (typeNode.type !== "TSTypeReference") {
+        return null;
+      }
+      if (!isGreaterThanTypeReference(typeNode)) {
+        return null;
+      }
+      return getComparatorTypeArgumentTexts(typeNode);
+    };
+    const getDirectLessThanOrEqualReplacement = (conditionalTypeNode) => {
+      const comparatorTypeArgumentTexts = getComparatorTypeArgumentTextsFromTypeNode(conditionalTypeNode.checkType);
+      if (!comparatorTypeArgumentTexts) {
+        return null;
+      }
+      if (!isTrueLiteralType2(conditionalTypeNode.extendsType) || !isFalseLiteralType(conditionalTypeNode.trueType) || !isTrueLiteralType2(conditionalTypeNode.falseType)) {
+        return null;
+      }
+      return comparatorTypeArgumentTexts;
+    };
+    const getInferWrappedLessThanOrEqualReplacement = (conditionalTypeNode) => {
+      const comparatorTypeArgumentTexts = getComparatorTypeArgumentTextsFromTypeNode(conditionalTypeNode.checkType);
+      if (!comparatorTypeArgumentTexts) {
+        return null;
+      }
+      if (conditionalTypeNode.extendsType.type !== "TSInferType" || conditionalTypeNode.falseType.type !== "TSNeverKeyword" || conditionalTypeNode.trueType.type !== "TSConditionalType") {
+        return null;
+      }
+      const inferIdentifierName = conditionalTypeNode.extendsType.typeParameter.name.name;
+      const innerConditionalTypeNode = conditionalTypeNode.trueType;
+      if (innerConditionalTypeNode.checkType.type !== "TSTypeReference" || innerConditionalTypeNode.checkType.typeName.type !== "Identifier" || innerConditionalTypeNode.checkType.typeName.name !== inferIdentifierName || innerConditionalTypeNode.checkType.typeArguments !== void 0 || !isTrueLiteralType2(innerConditionalTypeNode.extendsType) || !isFalseLiteralType(innerConditionalTypeNode.trueType) || !isTrueLiteralType2(innerConditionalTypeNode.falseType)) {
+        return null;
+      }
+      return comparatorTypeArgumentTexts;
+    };
+    const getLessThanOrEqualReplacementText = (conditionalTypeNode) => {
+      const comparatorTypeArgumentTexts = getDirectLessThanOrEqualReplacement(conditionalTypeNode) ?? getInferWrappedLessThanOrEqualReplacement(conditionalTypeNode);
+      if (!comparatorTypeArgumentTexts) {
+        return null;
+      }
+      return `${LESS_THAN_OR_EQUAL_TYPE_NAME}<${comparatorTypeArgumentTexts.leftTypeText}, ${comparatorTypeArgumentTexts.rightTypeText}>`;
+    };
+    return {
+      TSConditionalType(node) {
+        const replacementText = getLessThanOrEqualReplacementText(node);
+        if (replacementText === null || replacementText.length === 0) {
+          return;
+        }
+        const fix = createSafeTypeNodeTextReplacementFix(node, LESS_THAN_OR_EQUAL_TYPE_NAME, replacementText, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix,
+          messageId: "preferLessThanOrEqual",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest LessThanOrEqual over `GreaterThan<A, B> extends true ? false : true` wrappers.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-less-than-or-equal"
+    },
+    fixable: "code",
+    messages: {
+      preferLessThanOrEqual: "Prefer `LessThanOrEqual<A, B>` from type-fest over wrappers built from `GreaterThan<A, B>`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-less-than-or-equal"
+});
+var prefer_type_fest_less_than_or_equal_default = preferTypeFestLessThanOrEqualRule;
+
+// dist/rules/prefer-type-fest-less-than.js
+var GREATER_THAN_OR_EQUAL_TYPE_NAME = "GreaterThanOrEqual";
+var LESS_THAN_TYPE_NAME = "LessThan";
+var isLiteralBooleanType2 = (node, expectedBooleanValue) => node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === expectedBooleanValue;
+var isFalseLiteralType2 = (node) => isLiteralBooleanType2(node, false);
+var isTrueLiteralType3 = (node) => isLiteralBooleanType2(node, true);
+var preferTypeFestLessThanRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const greaterThanOrEqualLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, GREATER_THAN_OR_EQUAL_TYPE_NAME);
+    const typeFestNamespaceImportNames = collectNamespaceImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const getComparatorTypeArgumentTexts = (typeReference) => {
+      const typeArguments = typeReference.typeArguments?.params ?? [];
+      const [leftType, rightType] = typeArguments;
+      if (!leftType || !rightType || typeArguments.length !== 2) {
+        return null;
+      }
+      return {
+        leftTypeText: context.sourceCode.getText(leftType),
+        rightTypeText: context.sourceCode.getText(rightType)
+      };
+    };
+    const isGreaterThanOrEqualTypeReference = (typeReference) => {
+      if (typeReference.typeName.type === "Identifier") {
+        return setContainsValue(greaterThanOrEqualLocalNames, typeReference.typeName.name);
+      }
+      if (typeReference.typeName.type !== "TSQualifiedName") {
+        return false;
+      }
+      return typeReference.typeName.left.type === "Identifier" && setContainsValue(typeFestNamespaceImportNames, typeReference.typeName.left.name) && typeReference.typeName.right.type === "Identifier" && typeReference.typeName.right.name === GREATER_THAN_OR_EQUAL_TYPE_NAME;
+    };
+    const getComparatorTypeArgumentTextsFromTypeNode = (typeNode) => {
+      if (typeNode.type !== "TSTypeReference") {
+        return null;
+      }
+      if (!isGreaterThanOrEqualTypeReference(typeNode)) {
+        return null;
+      }
+      return getComparatorTypeArgumentTexts(typeNode);
+    };
+    const getDirectLessThanReplacement = (conditionalTypeNode) => {
+      const comparatorTypeArgumentTexts = getComparatorTypeArgumentTextsFromTypeNode(conditionalTypeNode.checkType);
+      if (!comparatorTypeArgumentTexts) {
+        return null;
+      }
+      if (!isTrueLiteralType3(conditionalTypeNode.extendsType) || !isFalseLiteralType2(conditionalTypeNode.trueType) || !isTrueLiteralType3(conditionalTypeNode.falseType)) {
+        return null;
+      }
+      return comparatorTypeArgumentTexts;
+    };
+    const getInferWrappedLessThanReplacement = (conditionalTypeNode) => {
+      const comparatorTypeArgumentTexts = getComparatorTypeArgumentTextsFromTypeNode(conditionalTypeNode.checkType);
+      if (!comparatorTypeArgumentTexts) {
+        return null;
+      }
+      if (conditionalTypeNode.extendsType.type !== "TSInferType" || conditionalTypeNode.falseType.type !== "TSNeverKeyword" || conditionalTypeNode.trueType.type !== "TSConditionalType") {
+        return null;
+      }
+      const inferIdentifierName = conditionalTypeNode.extendsType.typeParameter.name.name;
+      const innerConditionalTypeNode = conditionalTypeNode.trueType;
+      if (innerConditionalTypeNode.checkType.type !== "TSTypeReference" || innerConditionalTypeNode.checkType.typeName.type !== "Identifier" || innerConditionalTypeNode.checkType.typeName.name !== inferIdentifierName || innerConditionalTypeNode.checkType.typeArguments !== void 0 || !isTrueLiteralType3(innerConditionalTypeNode.extendsType) || !isFalseLiteralType2(innerConditionalTypeNode.trueType) || !isTrueLiteralType3(innerConditionalTypeNode.falseType)) {
+        return null;
+      }
+      return comparatorTypeArgumentTexts;
+    };
+    const getLessThanReplacementText = (conditionalTypeNode) => {
+      const comparatorTypeArgumentTexts = getDirectLessThanReplacement(conditionalTypeNode) ?? getInferWrappedLessThanReplacement(conditionalTypeNode);
+      if (!comparatorTypeArgumentTexts) {
+        return null;
+      }
+      return `${LESS_THAN_TYPE_NAME}<${comparatorTypeArgumentTexts.leftTypeText}, ${comparatorTypeArgumentTexts.rightTypeText}>`;
+    };
+    return {
+      TSConditionalType(node) {
+        const replacementText = getLessThanReplacementText(node);
+        if (replacementText === null || replacementText.length === 0) {
+          return;
+        }
+        const fix = createSafeTypeNodeTextReplacementFix(node, LESS_THAN_TYPE_NAME, replacementText, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix,
+          messageId: "preferLessThan",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest LessThan over `GreaterThanOrEqual<A, B> extends true ? false : true` wrappers.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-less-than"
+    },
+    fixable: "code",
+    messages: {
+      preferLessThan: "Prefer `LessThan<A, B>` from type-fest over wrappers built from `GreaterThanOrEqual<A, B>`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-less-than"
+});
+var prefer_type_fest_less_than_default = preferTypeFestLessThanRule;
+
 // dist/rules/prefer-type-fest-literal-union.js
 var import_ts_extras35 = require("ts-extras");
 var literalUnionFamilies = [
@@ -7780,6 +8224,192 @@ var preferTypeFestOmitIndexSignatureRule = createTypedRule({
 });
 var prefer_type_fest_omit_index_signature_default = preferTypeFestOmitIndexSignatureRule;
 
+// dist/rules/prefer-type-fest-optional.js
+var import_ts_extras36 = require("ts-extras");
+var OPTIONAL_TYPE_NAME = "Optional";
+var EXCLUDE_TYPE_NAME = "Exclude";
+var NON_NULLABLE_TYPE_NAME = "NonNullable";
+var isNullKeywordType = (node) => node.type === "TSNullKeyword";
+var isUndefinedKeywordType = (node) => node.type === "TSUndefinedKeyword";
+var isNullishDeleteType = (node) => {
+  if (isNullKeywordType(node)) {
+    return true;
+  }
+  if (node.type !== "TSUnionType" || node.types.length !== 2) {
+    return false;
+  }
+  let hasNull = false;
+  let hasUndefined = false;
+  for (const member of node.types) {
+    if (isNullKeywordType(member)) {
+      hasNull = true;
+      continue;
+    }
+    if (isUndefinedKeywordType(member)) {
+      hasUndefined = true;
+      continue;
+    }
+    return false;
+  }
+  return hasNull && hasUndefined;
+};
+var getOptionalInnerTypeText = ({ sourceCode, typeNode }) => {
+  if (typeNode.type !== "TSTypeReference" || typeNode.typeName.type !== "Identifier") {
+    return null;
+  }
+  const typeArguments = typeNode.typeArguments?.params ?? [];
+  if (typeNode.typeName.name === NON_NULLABLE_TYPE_NAME) {
+    const [innerType2] = typeArguments;
+    return innerType2 ? sourceCode.getText(innerType2) : null;
+  }
+  if (typeNode.typeName.name !== EXCLUDE_TYPE_NAME) {
+    return null;
+  }
+  const [innerType, deletedType] = typeArguments;
+  if (!innerType || !deletedType || !isNullishDeleteType(deletedType)) {
+    return null;
+  }
+  return sourceCode.getText(innerType);
+};
+var preferTypeFestOptionalRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      TSUnionType(node) {
+        if (node.types.length !== 2) {
+          return;
+        }
+        const firstMember = (0, import_ts_extras36.arrayFirst)(node.types);
+        const secondMember = (0, import_ts_extras36.arrayAt)(node.types, 1);
+        if (!firstMember || !secondMember) {
+          return;
+        }
+        const optionalEquivalentMember = isUndefinedKeywordType(firstMember) ? secondMember : isUndefinedKeywordType(secondMember) ? firstMember : null;
+        if (!optionalEquivalentMember) {
+          return;
+        }
+        const innerTypeText = getOptionalInnerTypeText({
+          sourceCode: context.sourceCode,
+          typeNode: optionalEquivalentMember
+        });
+        if (innerTypeText === null || innerTypeText.trim().length === 0) {
+          return;
+        }
+        const fix = createSafeTypeNodeTextReplacementFix(node, OPTIONAL_TYPE_NAME, `${OPTIONAL_TYPE_NAME}<${innerTypeText}>`, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix,
+          messageId: "preferOptional",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest Optional over `Exclude<T, null> | undefined` and `NonNullable<T> | undefined` patterns.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-optional"
+    },
+    fixable: "code",
+    messages: {
+      preferOptional: "Prefer `Optional<T>` from type-fest over `Exclude<T, null> | undefined` and equivalent optional-value patterns."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-optional"
+});
+var prefer_type_fest_optional_default = preferTypeFestOptionalRule;
+
+// dist/rules/prefer-type-fest-or-all.js
+var SOME_EXTEND_TYPE_NAME = "SomeExtend";
+var OR_ALL_TYPE_NAME = "OrAll";
+var isTrueLiteralType4 = (node) => node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === true;
+var preferTypeFestOrAllRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const someExtendLocalNames = collectNamedImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE, SOME_EXTEND_TYPE_NAME);
+    const typeFestNamespaceImportNames = collectNamespaceImportLocalNamesFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    const getSomeExtendTupleArgumentText = (typeReference) => {
+      const typeArguments = typeReference.typeArguments?.params ?? [];
+      const [tupleArgument, comparedType] = typeArguments;
+      if (!tupleArgument || !comparedType || !isTrueLiteralType4(comparedType)) {
+        return null;
+      }
+      if (typeArguments.length !== 2) {
+        return null;
+      }
+      return context.sourceCode.getText(tupleArgument);
+    };
+    const reportIfSomeExtendEquivalent = (node) => {
+      const tupleArgumentText = getSomeExtendTupleArgumentText(node);
+      if (tupleArgumentText === null || tupleArgumentText.trim().length === 0) {
+        return;
+      }
+      const fix = createSafeTypeNodeTextReplacementFix(node, OR_ALL_TYPE_NAME, `${OR_ALL_TYPE_NAME}<${tupleArgumentText}>`, typeFestDirectImports);
+      reportWithOptionalFix({
+        context,
+        fix,
+        messageId: "preferOrAll",
+        node
+      });
+    };
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(typeReference) {
+        if (typeReference.typeName.type !== "Identifier" || !setContainsValue(someExtendLocalNames, typeReference.typeName.name)) {
+          return;
+        }
+        reportIfSomeExtendEquivalent(typeReference);
+      },
+      'TSTypeReference[typeName.type="TSQualifiedName"]'(typeReference) {
+        if (typeReference.typeName.type !== "TSQualifiedName") {
+          return;
+        }
+        if (typeReference.typeName.left.type !== "Identifier" || !setContainsValue(typeFestNamespaceImportNames, typeReference.typeName.left.name) || typeReference.typeName.right.type !== "Identifier" || typeReference.typeName.right.name !== SOME_EXTEND_TYPE_NAME) {
+          return;
+        }
+        reportIfSomeExtendEquivalent(typeReference);
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest OrAll over `SomeExtend<TTuple, true>` boolean-tuple checks.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-or-all"
+    },
+    fixable: "code",
+    messages: {
+      preferOrAll: "Prefer `OrAll<TTuple>` from type-fest over `SomeExtend<TTuple, true>` for boolean-tuple disjunction checks."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-or-all"
+});
+var prefer_type_fest_or_all_default = preferTypeFestOrAllRule;
+
 // dist/rules/prefer-type-fest-partial-deep.js
 var preferTypeFestPartialDeepRule = createTypedRule({
   create(context) {
@@ -7899,7 +8529,7 @@ var preferTypeFestPrimitiveRule = createTypedRule({
 var prefer_type_fest_primitive_default = preferTypeFestPrimitiveRule;
 
 // dist/rules/prefer-type-fest-promisable.js
-var import_ts_extras36 = require("ts-extras");
+var import_ts_extras37 = require("ts-extras");
 var PROMISABLE_TYPE_NAME = "Promisable";
 var PROMISE_TYPE_NAME = "Promise";
 var promisableAliasReplacements = {
@@ -7915,10 +8545,10 @@ var getPromiseInnerType = (node) => {
     return null;
   }
   const typeArguments = node.typeArguments?.params;
-  if (!(0, import_ts_extras36.isDefined)(typeArguments)) {
+  if (!(0, import_ts_extras37.isDefined)(typeArguments)) {
     return null;
   }
-  return (0, import_ts_extras36.arrayFirst)(typeArguments) ?? null;
+  return (0, import_ts_extras37.arrayFirst)(typeArguments) ?? null;
 };
 var preferTypeFestPromisableRule = createTypedRule({
   create(context, [options] = defaultOptions3) {
@@ -8979,6 +9609,195 @@ var preferTypeFestTupleOfRule = createTypedRule({
 });
 var prefer_type_fest_tuple_of_default = preferTypeFestTupleOfRule;
 
+// dist/rules/prefer-type-fest-union-member.js
+var import_ts_extras38 = require("ts-extras");
+var UNION_MEMBER_TYPE_NAME = "UnionMember";
+var UNION_TO_INTERSECTION_TYPE_NAME = "UnionToIntersection";
+var IS_NEVER_TYPE_NAME = "IsNever";
+var isIdentifierTypeReferenceNamed = (node, name) => node.type === "TSTypeReference" && node.typeName.type === "Identifier" && node.typeName.name === name;
+var isBooleanLiteralType = (node, expectedValue) => node.type === "TSLiteralType" && node.literal.type === "Literal" && node.literal.value === expectedValue;
+var getUnionArgumentTextFromDistributiveFunctionWrapper = ({ node, sourceCode }) => {
+  if (node.type !== "TSConditionalType") {
+    return null;
+  }
+  if (node.extendsType.type !== "TSAnyKeyword" || node.falseType.type !== "TSNeverKeyword") {
+    return null;
+  }
+  if (node.trueType.type !== "TSFunctionType") {
+    return null;
+  }
+  const returnType = node.trueType.returnType?.typeAnnotation;
+  if (!returnType) {
+    return null;
+  }
+  const checkTypeText = sourceCode.getText(node.checkType);
+  const returnTypeText = sourceCode.getText(returnType);
+  return checkTypeText === returnTypeText ? checkTypeText : null;
+};
+var getUnionArgumentTextFromExtractor = ({ node, sourceCode }) => {
+  if (node.falseType.type !== "TSNeverKeyword") {
+    return null;
+  }
+  if (!isIdentifierTypeReferenceNamed(node.checkType, UNION_TO_INTERSECTION_TYPE_NAME)) {
+    return null;
+  }
+  const extractorArgument = (0, import_ts_extras38.arrayFirst)(node.checkType.typeArguments?.params ?? []);
+  if (!extractorArgument) {
+    return null;
+  }
+  const unionArgumentText = getUnionArgumentTextFromDistributiveFunctionWrapper({
+    node: extractorArgument,
+    sourceCode
+  });
+  if (unionArgumentText === null) {
+    return null;
+  }
+  if (node.extendsType.type !== "TSFunctionType") {
+    return null;
+  }
+  const inferredReturnType = node.extendsType.returnType?.typeAnnotation;
+  const inferredTypeParameterName = inferredReturnType?.type === "TSInferType" ? inferredReturnType.typeParameter.name.name : null;
+  if (inferredTypeParameterName === null || node.trueType.type !== "TSTypeReference" || node.trueType.typeName.type !== "Identifier" || node.trueType.typeName.name !== inferredTypeParameterName) {
+    return null;
+  }
+  return unionArgumentText;
+};
+var getUnionMemberEquivalentArgumentText = ({ node, sourceCode }) => {
+  if (node.type !== "TSConditionalType") {
+    return null;
+  }
+  const directExtractorText = getUnionArgumentTextFromExtractor({
+    node,
+    sourceCode
+  });
+  if (directExtractorText !== null) {
+    return directExtractorText;
+  }
+  if (!isIdentifierTypeReferenceNamed(node.checkType, IS_NEVER_TYPE_NAME) || !isBooleanLiteralType(node.extendsType, true) || node.trueType.type !== "TSNeverKeyword") {
+    return null;
+  }
+  const guardedArgument = (0, import_ts_extras38.arrayFirst)(node.checkType.typeArguments?.params ?? []);
+  if (!guardedArgument) {
+    return null;
+  }
+  const guardedArgumentText = sourceCode.getText(guardedArgument);
+  if (node.falseType.type !== "TSConditionalType") {
+    return null;
+  }
+  const extractorText = getUnionArgumentTextFromExtractor({
+    node: node.falseType,
+    sourceCode
+  });
+  return extractorText === guardedArgumentText ? extractorText : null;
+};
+var preferTypeFestUnionMemberRule = createTypedRule({
+  create(context) {
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      TSTypeAliasDeclaration(node) {
+        const unionArgumentText = getUnionMemberEquivalentArgumentText({
+          node: node.typeAnnotation,
+          sourceCode: context.sourceCode
+        });
+        if (unionArgumentText === null || unionArgumentText.trim().length === 0) {
+          return;
+        }
+        const fix = createSafeTypeNodeTextReplacementFix(node.typeAnnotation, UNION_MEMBER_TYPE_NAME, `${UNION_MEMBER_TYPE_NAME}<${unionArgumentText}>`, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          fix,
+          messageId: "preferUnionMember",
+          node: node.typeAnnotation
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest UnionMember over custom union-member extraction helpers based on `UnionToIntersection`.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-union-member"
+    },
+    fixable: "code",
+    messages: {
+      preferUnionMember: "Prefer `UnionMember<T>` from type-fest over custom union-member extraction helpers based on `UnionToIntersection`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-union-member"
+});
+var prefer_type_fest_union_member_default = preferTypeFestUnionMemberRule;
+
+// dist/rules/prefer-type-fest-union-to-tuple.js
+var unionToTupleAliasReplacements = {
+  TupleFromUnion: "UnionToTuple",
+  TuplifyUnion: "UnionToTuple"
+};
+var preferTypeFestUnionToTupleRule = createTypedRule({
+  create(context) {
+    const importedAliasMatches = collectImportedTypeAliasMatches(context.sourceCode, unionToTupleAliasReplacements);
+    const typeFestDirectImports = collectDirectNamedImportsFromSource(context.sourceCode, TYPE_FEST_MODULE_SOURCE);
+    return {
+      'TSTypeReference[typeName.type="Identifier"]'(node) {
+        if (node.typeName.type !== "Identifier") {
+          return;
+        }
+        const importedAliasMatch = importedAliasMatches.get(node.typeName.name);
+        if (!importedAliasMatch) {
+          return;
+        }
+        const aliasReplacementFix = createSafeTypeReferenceReplacementFix(node, importedAliasMatch.replacementName, typeFestDirectImports);
+        reportWithOptionalFix({
+          context,
+          data: {
+            alias: importedAliasMatch.importedName,
+            replacement: importedAliasMatch.replacementName
+          },
+          fix: aliasReplacementFix,
+          messageId: "preferUnionToTuple",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    deprecated: false,
+    docs: {
+      description: "require TypeFest UnionToTuple over imported aliases such as TuplifyUnion.",
+      frozen: false,
+      recommended: true,
+      requiresTypeChecking: false,
+      typefestConfigs: [
+        "typefest.configs.recommended",
+        "typefest.configs.strict",
+        "typefest.configs.all",
+        "typefest.configs.type-fest/types"
+      ],
+      url: "https://nick2bad4u.github.io/eslint-plugin-typefest/docs/rules/prefer-type-fest-union-to-tuple"
+    },
+    fixable: "code",
+    messages: {
+      preferUnionToTuple: "Prefer `{{replacement}}` from type-fest to convert unions into tuple forms instead of legacy alias `{{alias}}`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-type-fest-union-to-tuple"
+});
+var prefer_type_fest_union_to_tuple_default = preferTypeFestUnionToTupleRule;
+
 // dist/rules/prefer-type-fest-unknown-array.js
 var READONLY_ARRAY_TYPE_NAME2 = "ReadonlyArray";
 var UNKNOWN_ARRAY_TYPE_NAME = "UnknownArray";
@@ -9532,9 +10351,12 @@ var typefestRuleRegistry = {
   "prefer-ts-extras-set-has": prefer_ts_extras_set_has_default,
   "prefer-ts-extras-string-split": prefer_ts_extras_string_split_default,
   "prefer-type-fest-abstract-constructor": prefer_type_fest_abstract_constructor_default,
+  "prefer-type-fest-and-all": prefer_type_fest_and_all_default,
+  "prefer-type-fest-array-length": prefer_type_fest_array_length_default,
   "prefer-type-fest-arrayable": prefer_type_fest_arrayable_default,
   "prefer-type-fest-async-return-type": prefer_type_fest_async_return_type_default,
   "prefer-type-fest-conditional-pick": prefer_type_fest_conditional_pick_default,
+  "prefer-type-fest-conditional-pick-deep": prefer_type_fest_conditional_pick_deep_default,
   "prefer-type-fest-constructor": prefer_type_fest_constructor_default,
   "prefer-type-fest-except": prefer_type_fest_except_default,
   "prefer-type-fest-if": prefer_type_fest_if_default,
@@ -9544,10 +10366,14 @@ var typefestRuleRegistry = {
   "prefer-type-fest-json-primitive": prefer_type_fest_json_primitive_default,
   "prefer-type-fest-json-value": prefer_type_fest_json_value_default,
   "prefer-type-fest-keys-of-union": prefer_type_fest_keys_of_union_default,
+  "prefer-type-fest-less-than": prefer_type_fest_less_than_default,
+  "prefer-type-fest-less-than-or-equal": prefer_type_fest_less_than_or_equal_default,
   "prefer-type-fest-literal-union": prefer_type_fest_literal_union_default,
   "prefer-type-fest-merge-exclusive": prefer_type_fest_merge_exclusive_default,
   "prefer-type-fest-non-empty-tuple": prefer_type_fest_non_empty_tuple_default,
   "prefer-type-fest-omit-index-signature": prefer_type_fest_omit_index_signature_default,
+  "prefer-type-fest-optional": prefer_type_fest_optional_default,
+  "prefer-type-fest-or-all": prefer_type_fest_or_all_default,
   "prefer-type-fest-partial-deep": prefer_type_fest_partial_deep_default,
   "prefer-type-fest-primitive": prefer_type_fest_primitive_default,
   "prefer-type-fest-promisable": prefer_type_fest_promisable_default,
@@ -9565,6 +10391,8 @@ var typefestRuleRegistry = {
   "prefer-type-fest-simplify": prefer_type_fest_simplify_default,
   "prefer-type-fest-tagged-brands": prefer_type_fest_tagged_brands_default,
   "prefer-type-fest-tuple-of": prefer_type_fest_tuple_of_default,
+  "prefer-type-fest-union-member": prefer_type_fest_union_member_default,
+  "prefer-type-fest-union-to-tuple": prefer_type_fest_union_to_tuple_default,
   "prefer-type-fest-unknown-array": prefer_type_fest_unknown_array_default,
   "prefer-type-fest-unknown-map": prefer_type_fest_unknown_map_default,
   "prefer-type-fest-unknown-record": prefer_type_fest_unknown_record_default,
@@ -9586,7 +10414,7 @@ function getPackageVersion(pkg) {
   const version = Reflect.get(pkg, "version");
   return typeof version === "string" ? version : "0.0.0";
 }
-var packageJsonValue = (0, import_ts_extras37.safeCastTo)(package_default);
+var packageJsonValue = (0, import_ts_extras39.safeCastTo)(package_default);
 var typeScriptParserValue = import_parser3.default;
 var defaultParserOptions = {
   ecmaVersion: "latest",
@@ -9594,10 +10422,10 @@ var defaultParserOptions = {
 };
 var normalizeParserOptions = (parserOptions) => parserOptions !== null && typeof parserOptions === "object" && !Array.isArray(parserOptions) ? { ...parserOptions } : { ...defaultParserOptions };
 var typefestEslintRules = typefestRules;
-var isTypefestRuleName = (value) => (0, import_ts_extras37.objectHasIn)(typefestRules, value);
+var isTypefestRuleName = (value) => (0, import_ts_extras39.objectHasIn)(typefestRules, value);
 var typefestRuleEntries = (() => {
   const entries = [];
-  for (const [ruleName] of (0, import_ts_extras37.objectEntries)(typefestRules)) {
+  for (const [ruleName] of (0, import_ts_extras39.objectEntries)(typefestRules)) {
     if (!isTypefestRuleName(ruleName)) {
       continue;
     }
@@ -9624,7 +10452,7 @@ var derivePresetRuleNamesByConfig = () => {
   const presetRuleNamesByConfig2 = createEmptyPresetRuleMap();
   for (const [ruleName] of typefestRuleEntries) {
     const configNames = rulePresetMembership[ruleName];
-    if (!(0, import_ts_extras37.isDefined)(configNames) || (0, import_ts_extras37.isEmpty)(configNames)) {
+    if (!(0, import_ts_extras39.isDefined)(configNames) || (0, import_ts_extras39.isEmpty)(configNames)) {
       throw new TypeError(`Rule '${ruleName}' is missing preset membership metadata.`);
     }
     for (const configName of configNames) {
@@ -9651,7 +10479,7 @@ function errorRulesFor(ruleNames) {
 var presetRuleNamesByConfig = derivePresetRuleNamesByConfig();
 var recommendedRuleNames = [];
 for (const ruleName of presetRuleNamesByConfig.recommended) {
-  if ((0, import_ts_extras37.setHas)(typeCheckedRuleNames, ruleName)) {
+  if ((0, import_ts_extras39.setHas)(typeCheckedRuleNames, ruleName)) {
     continue;
   }
   recommendedRuleNames.push(ruleName);
@@ -9669,7 +10497,7 @@ function withTypefestPlugin(config, plugin, options) {
   const existingLanguageOptions = config.languageOptions ?? {};
   const existingParserOptions = existingLanguageOptions["parserOptions"];
   const parserOptions = normalizeParserOptions(existingParserOptions);
-  if (options.requiresTypeChecking && !(0, import_ts_extras37.objectHasIn)(parserOptions, "projectService")) {
+  if (options.requiresTypeChecking && !(0, import_ts_extras39.objectHasIn)(parserOptions, "projectService")) {
     Reflect.set(parserOptions, "projectService", true);
   }
   const languageOptions = {