@typescript-eslint/eslint-plugin 8.31.2-alpha.7 → 8.32.0

package/dist/configs/eslintrc/all.d.ts

@@ -89,6 +89,7 @@ declare const _default: {
         '@typescript-eslint/no-unnecessary-type-arguments': "error";
         '@typescript-eslint/no-unnecessary-type-assertion': "error";
         '@typescript-eslint/no-unnecessary-type-constraint': "error";
+        '@typescript-eslint/no-unnecessary-type-conversion': "error";
         '@typescript-eslint/no-unnecessary-type-parameters': "error";
         '@typescript-eslint/no-unsafe-argument': "error";
         '@typescript-eslint/no-unsafe-assignment': "error";

package/dist/configs/eslintrc/all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBAyJiC"}
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA0JiC"}

package/dist/configs/eslintrc/all.js

@@ -96,6 +96,7 @@ module.exports = {
         '@typescript-eslint/no-unnecessary-type-arguments': 'error',
         '@typescript-eslint/no-unnecessary-type-assertion': 'error',
         '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+        '@typescript-eslint/no-unnecessary-type-conversion': 'error',
         '@typescript-eslint/no-unnecessary-type-parameters': 'error',
         '@typescript-eslint/no-unsafe-argument': 'error',
         '@typescript-eslint/no-unsafe-assignment': 'error',

package/dist/configs/eslintrc/disable-type-checked.d.ts

@@ -29,6 +29,7 @@ declare const _default: {
         '@typescript-eslint/no-unnecessary-template-expression': "off";
         '@typescript-eslint/no-unnecessary-type-arguments': "off";
         '@typescript-eslint/no-unnecessary-type-assertion': "off";
+        '@typescript-eslint/no-unnecessary-type-conversion': "off";
         '@typescript-eslint/no-unnecessary-type-parameters': "off";
         '@typescript-eslint/no-unsafe-argument': "off";
         '@typescript-eslint/no-unsafe-assignment': "off";

package/dist/configs/eslintrc/disable-type-checked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA8DiC"}
+{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/eslintrc/disable-type-checked.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,kBA+DiC"}

package/dist/configs/eslintrc/disable-type-checked.js

@@ -32,6 +32,7 @@ module.exports = {
         '@typescript-eslint/no-unnecessary-template-expression': 'off',
         '@typescript-eslint/no-unnecessary-type-arguments': 'off',
         '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+        '@typescript-eslint/no-unnecessary-type-conversion': 'off',
         '@typescript-eslint/no-unnecessary-type-parameters': 'off',
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',

package/dist/configs/flat/all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAiKE"}
+{"version":3,"file":"all.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/all.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAKrE;;;GAGG;yBAED,QAAQ,UAAU,CAAC,MAAM,EACzB,QAAQ,UAAU,CAAC,MAAM,KACxB,UAAU,CAAC,WAAW;AAHzB,wBAkKE"}

package/dist/configs/flat/all.js

@@ -109,6 +109,7 @@ exports.default = (plugin, parser) => [
             '@typescript-eslint/no-unnecessary-type-arguments': 'error',
             '@typescript-eslint/no-unnecessary-type-assertion': 'error',
             '@typescript-eslint/no-unnecessary-type-constraint': 'error',
+            '@typescript-eslint/no-unnecessary-type-conversion': 'error',
             '@typescript-eslint/no-unnecessary-type-parameters': 'error',
             '@typescript-eslint/no-unsafe-argument': 'error',
             '@typescript-eslint/no-unsafe-assignment': 'error',

package/dist/configs/flat/disable-type-checked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAoEG"}
+{"version":3,"file":"disable-type-checked.d.ts","sourceRoot":"","sources":["../../../src/configs/flat/disable-type-checked.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAErE;;;GAGG;yBAED,SAAS,UAAU,CAAC,MAAM,EAC1B,SAAS,UAAU,CAAC,MAAM,KACzB,UAAU,CAAC,MAAM;AAHpB,wBAqEG"}

package/dist/configs/flat/disable-type-checked.js

@@ -37,6 +37,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/no-unnecessary-template-expression': 'off',
         '@typescript-eslint/no-unnecessary-type-arguments': 'off',
         '@typescript-eslint/no-unnecessary-type-assertion': 'off',
+        '@typescript-eslint/no-unnecessary-type-conversion': 'off',
         '@typescript-eslint/no-unnecessary-type-parameters': 'off',
         '@typescript-eslint/no-unsafe-argument': 'off',
         '@typescript-eslint/no-unsafe-assignment': 'off',

package/dist/index.d.ts

@@ -91,6 +91,7 @@ declare const _default: {
                 '@typescript-eslint/no-unnecessary-type-arguments': "error";
                 '@typescript-eslint/no-unnecessary-type-assertion': "error";
                 '@typescript-eslint/no-unnecessary-type-constraint': "error";
+                '@typescript-eslint/no-unnecessary-type-conversion': "error";
                 '@typescript-eslint/no-unnecessary-type-parameters': "error";
                 '@typescript-eslint/no-unsafe-argument': "error";
                 '@typescript-eslint/no-unsafe-assignment': "error";
@@ -192,6 +193,7 @@ declare const _default: {
                 '@typescript-eslint/no-unnecessary-template-expression': "off";
                 '@typescript-eslint/no-unnecessary-type-arguments': "off";
                 '@typescript-eslint/no-unnecessary-type-assertion': "off";
+                '@typescript-eslint/no-unnecessary-type-conversion': "off";
                 '@typescript-eslint/no-unnecessary-type-parameters': "off";
                 '@typescript-eslint/no-unsafe-argument': "off";
                 '@typescript-eslint/no-unsafe-assignment': "off";
@@ -774,6 +776,7 @@ declare const _default: {
         'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unnecessary-type-assertion").MessageIds, import("./rules/no-unnecessary-type-assertion").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unsafe-argument").MessageIds, [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAA0B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAA0B"}

package/dist/raw-plugin.d.ts

@@ -113,6 +113,7 @@ declare const _default: {
                     '@typescript-eslint/no-unnecessary-type-arguments': "error";
                     '@typescript-eslint/no-unnecessary-type-assertion': "error";
                     '@typescript-eslint/no-unnecessary-type-constraint': "error";
+                    '@typescript-eslint/no-unnecessary-type-conversion': "error";
                     '@typescript-eslint/no-unnecessary-type-parameters': "error";
                     '@typescript-eslint/no-unsafe-argument': "error";
                     '@typescript-eslint/no-unsafe-assignment': "error";
@@ -214,6 +215,7 @@ declare const _default: {
                     '@typescript-eslint/no-unnecessary-template-expression': "off";
                     '@typescript-eslint/no-unnecessary-type-arguments': "off";
                     '@typescript-eslint/no-unnecessary-type-assertion': "off";
+                    '@typescript-eslint/no-unnecessary-type-conversion': "off";
                     '@typescript-eslint/no-unnecessary-type-parameters': "off";
                     '@typescript-eslint/no-unsafe-argument': "off";
                     '@typescript-eslint/no-unsafe-assignment': "off";
@@ -797,6 +799,7 @@ declare const _default: {
             'no-unnecessary-type-arguments': TSESLint.RuleModule<"unnecessaryTypeParameter", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unnecessary-type-assertion': TSESLint.RuleModule<import("./rules/no-unnecessary-type-assertion").MessageIds, import("./rules/no-unnecessary-type-assertion").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unnecessary-type-constraint': TSESLint.RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-unnecessary-type-conversion': TSESLint.RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unnecessary-type-parameters': TSESLint.RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-argument': TSESLint.RuleModule<import("./rules/no-unsafe-argument").MessageIds, [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unsafe-assignment': TSESLint.RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

package/dist/raw-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}
+{"version":3,"file":"raw-plugin.d.ts","sourceRoot":"","sources":["../src/raw-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,oCAAoC,CAAC;;;;;;;;;;;;;;;;;;wDAetD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqCpB,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDvE,kBAIE"}

package/dist/rules/adjacent-overload-signatures.js

@@ -50,7 +50,7 @@ exports.default = (0, util_1.createRule)({
                     return {
                         ...(0, util_1.getNameFromMember)(member, context.sourceCode),
                         callSignature: false,
-                        static: !!member.static,
+                        static: member.static,
                     };
                 case utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration:
                     return {

package/dist/rules/await-thenable.js

@@ -87,7 +87,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const hasAsyncIteratorSymbol = tsutils
-                    .unionTypeParts(type)
+                    .unionConstituents(type)
                     .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncIterator', checker) != null);
                 if (!hasAsyncIteratorSymbol) {
                     context.report({
@@ -118,7 +118,7 @@ exports.default = (0, util_1.createRule)({
                         continue;
                     }
                     const hasAsyncDisposeSymbol = tsutils
-                        .unionTypeParts(type)
+                        .unionConstituents(type)
                         .some(typePart => tsutils.getWellKnownSymbolPropertyOfType(typePart, 'asyncDispose', checker) != null);
                     if (!hasAsyncDisposeSymbol) {
                         context.report({

package/dist/rules/enum-utils/shared.js

@@ -66,7 +66,7 @@ function getBaseEnumType(typeChecker, type) {
  */
 function getEnumLiterals(type) {
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .filter((subType) => (0, util_1.isTypeFlagSet)(subType, ts.TypeFlags.EnumLiteral));
 }
 /**

package/dist/rules/explicit-function-return-type.js

@@ -116,13 +116,13 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                 }
-                if (!!funcName && !!options.allowedNames.includes(funcName)) {
+                if (!!funcName && options.allowedNames.includes(funcName)) {
                     return true;
                 }
             }
             if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
                 node.id &&
-                !!options.allowedNames.includes(node.id.name)) {
+                options.allowedNames.includes(node.id.name)) {
                 return true;
             }
             return false;

package/dist/rules/index.d.ts

@@ -107,6 +107,7 @@ declare const rules: {
     'no-unnecessary-type-arguments': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnecessaryTypeParameter", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unnecessary-type-assertion': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unnecessary-type-assertion").MessageIds, import("./no-unnecessary-type-assertion").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unnecessary-type-constraint': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeUnnecessaryConstraint" | "unnecessaryConstraint", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unnecessary-type-conversion': import("@typescript-eslint/utils/ts-eslint").RuleModule<"suggestRemove" | "suggestSatisfies" | "unnecessaryTypeConversion", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unnecessary-type-parameters': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceUsagesWithConstraint" | "sole", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-argument': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unsafe-argument").MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unsafe-assignment': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unsafeArraySpread" | "anyAssignment" | "anyAssignmentThis" | "unsafeArrayPattern" | "unsafeArrayPatternFromTuple" | "unsafeAssignment", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/rules/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAqIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rules/index.ts"],"names":[],"mappings":"AAsIA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqImB,CAAC;AAE/B,SAAS,KAAK,CAAC"}

package/dist/rules/index.js

@@ -77,6 +77,7 @@ const no_unnecessary_template_expression_1 = __importDefault(require("./no-unnec
 const no_unnecessary_type_arguments_1 = __importDefault(require("./no-unnecessary-type-arguments"));
 const no_unnecessary_type_assertion_1 = __importDefault(require("./no-unnecessary-type-assertion"));
 const no_unnecessary_type_constraint_1 = __importDefault(require("./no-unnecessary-type-constraint"));
+const no_unnecessary_type_conversion_1 = __importDefault(require("./no-unnecessary-type-conversion"));
 const no_unnecessary_type_parameters_1 = __importDefault(require("./no-unnecessary-type-parameters"));
 const no_unsafe_argument_1 = __importDefault(require("./no-unsafe-argument"));
 const no_unsafe_assignment_1 = __importDefault(require("./no-unsafe-assignment"));
@@ -208,6 +209,7 @@ const rules = {
     'no-unnecessary-type-arguments': no_unnecessary_type_arguments_1.default,
     'no-unnecessary-type-assertion': no_unnecessary_type_assertion_1.default,
     'no-unnecessary-type-constraint': no_unnecessary_type_constraint_1.default,
+    'no-unnecessary-type-conversion': no_unnecessary_type_conversion_1.default,
     'no-unnecessary-type-parameters': no_unnecessary_type_parameters_1.default,
     'no-unsafe-argument': no_unsafe_argument_1.default,
     'no-unsafe-assignment': no_unsafe_assignment_1.default,

package/dist/rules/member-ordering.js

@@ -326,7 +326,7 @@ function isMemberOptional(node) {
         case utils_1.AST_NODE_TYPES.PropertyDefinition:
         case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
         case utils_1.AST_NODE_TYPES.MethodDefinition:
-            return !!node.optional;
+            return node.optional;
     }
     return false;
 }

package/dist/rules/no-confusing-void-expression.js

@@ -327,7 +327,7 @@ exports.default = (0, util_1.createRule)({
             return callSignatures.some(signature => {
                 const returnType = signature.getReturnType();
                 return tsutils
-                    .unionTypeParts(returnType)
+                    .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             });
         }
@@ -342,14 +342,14 @@ exports.default = (0, util_1.createRule)({
             if (functionTSNode.type) {
                 const returnType = checker.getTypeFromTypeNode(functionTSNode.type);
                 return tsutils
-                    .unionTypeParts(returnType)
+                    .unionConstituents(returnType)
                     .some(tsutils.isIntrinsicVoidType);
             }
             if (ts.isExpression(functionTSNode)) {
                 const functionType = checker.getContextualType(functionTSNode);
                 if (functionType) {
                     return tsutils
-                        .unionTypeParts(functionType)
+                        .unionConstituents(functionType)
                         .some(isFunctionReturnTypeIncludesVoid);
                 }
             }

package/dist/rules/no-duplicate-enum-values.js

@@ -39,10 +39,10 @@ exports.default = (0, util_1.createRule)({
                     }
                     let value;
                     if (isStringLiteral(member.initializer)) {
-                        value = String(member.initializer.value);
+                        value = member.initializer.value;
                     }
                     else if (isNumberLiteral(member.initializer)) {
-                        value = Number(member.initializer.value);
+                        value = member.initializer.value;
                     }
                     else if (isStaticTemplateLiteral(member.initializer)) {
                         value = member.initializer.quasis[0].value.cooked;

package/dist/rules/no-empty-interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-interface.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,kBAAkB,CAAC;;AAExD,wBAmHG"}
+{"version":3,"file":"no-empty-interface.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,kBAAkB,CAAC;;AAExD,wBAkHG"}

package/dist/rules/no-empty-interface.js

@@ -75,9 +75,9 @@ exports.default = (0, util_1.createRule)({
                     const mergedWithClassDeclaration = scope.set
                         .get(node.id.name)
                         ?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
-                    const isInAmbientDeclaration = !!((0, util_1.isDefinitionFile)(context.filename) &&
+                    const isInAmbientDeclaration = (0, util_1.isDefinitionFile)(context.filename) &&
                         scope.type === scope_manager_1.ScopeType.tsModule &&
-                        scope.block.declare);
+                        scope.block.declare;
                     const useAutoFix = !(isInAmbientDeclaration || mergedWithClassDeclaration);
                     context.report({
                         node: node.id,

package/dist/rules/no-floating-promises.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAepD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAkaG"}
+{"version":3,"file":"no-floating-promises.d.ts","sourceRoot":"","sources":["../../src/rules/no-floating-promises.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAC;AAMnE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAmBpD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,sBAAsB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAChD,yBAAyB,CAAC,EAAE,oBAAoB,EAAE,CAAC;QACnD,cAAc,CAAC,EAAE,OAAO,CAAC;QACzB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB;CACF,CAAC;AAEF,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,0BAA0B,GAC1B,iCAAiC,GACjC,qCAAqC,GACrC,cAAc,CAAC;;AAmBnB,wBAqZG"}

package/dist/rules/no-floating-promises.js

@@ -37,6 +37,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
+const promiseUtils_1 = require("../util/promiseUtils");
 const messageBase = 'Promises must be awaited, end with a call to .catch, or end with a call to .then with a rejection handler.';
 const messageBaseVoid = 'Promises must be awaited, end with a call to .catch, end with a call to .then with a rejection handler' +
     ' or be explicitly marked as ignored with the `void` operator.';
@@ -256,33 +257,20 @@ exports.default = (0, util_1.createRule)({
             if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
                 // If the outer expression is a call, a `.catch()` or `.then()` with
                 // rejection handler handles the promise.
-                const { callee } = node;
-                if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    const methodName = (0, util_1.getStaticMemberAccessValue)(callee, context);
-                    const catchRejectionHandler = methodName === 'catch' && node.arguments.length >= 1
-                        ? node.arguments[0]
-                        : undefined;
-                    if (catchRejectionHandler) {
-                        if (isValidRejectionHandler(catchRejectionHandler)) {
+                const promiseHandlingMethodCall = (0, promiseUtils_1.parseCatchCall)(node, context) ?? (0, promiseUtils_1.parseThenCall)(node, context);
+                if (promiseHandlingMethodCall != null) {
+                    const onRejected = promiseHandlingMethodCall.onRejected;
+                    if (onRejected != null) {
+                        if (isValidRejectionHandler(onRejected)) {
                             return { isUnhandled: false };
                         }
                         return { isUnhandled: true, nonFunctionHandler: true };
                     }
-                    const thenRejectionHandler = methodName === 'then' && node.arguments.length >= 2
-                        ? node.arguments[1]
-                        : undefined;
-                    if (thenRejectionHandler) {
-                        if (isValidRejectionHandler(thenRejectionHandler)) {
-                            return { isUnhandled: false };
-                        }
-                        return { isUnhandled: true, nonFunctionHandler: true };
-                    }
-                    // `x.finally()` is transparent to resolution of the promise, so check `x`.
-                    // ("object" in this context is the `x` in `x.finally()`)
-                    const promiseFinallyObject = methodName === 'finally' ? callee.object : undefined;
-                    if (promiseFinallyObject) {
-                        return isUnhandledPromise(checker, promiseFinallyObject);
-                    }
+                    return { isUnhandled: true };
+                }
+                const promiseFinallyCall = (0, promiseUtils_1.parseFinallyCall)(node, context);
+                if (promiseFinallyCall != null) {
+                    return isUnhandledPromise(checker, promiseFinallyCall.object);
                 }
                 // All other cases are unhandled.
                 return { isUnhandled: true };
@@ -309,7 +297,7 @@ exports.default = (0, util_1.createRule)({
         function isPromiseArray(node) {
             const type = checker.getTypeAtLocation(node);
             for (const ty of tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .map(t => checker.getApparentType(t))) {
                 if (checker.isArrayType(ty)) {
                     const arrayType = checker.getTypeArguments(ty)[0];
@@ -334,7 +322,7 @@ exports.default = (0, util_1.createRule)({
                 return false;
             }
             // Otherwise, we always consider the built-in Promise to be Promise-like...
-            const typeParts = tsutils.unionTypeParts(checker.getApparentType(type));
+            const typeParts = tsutils.unionConstituents(checker.getApparentType(type));
             if (typeParts.some(typePart => (0, util_1.isBuiltinSymbolLike)(services.program, typePart, 'Promise'))) {
                 return true;
             }
@@ -363,7 +351,7 @@ exports.default = (0, util_1.createRule)({
     },
 });
 function hasMatchingSignature(type, matcher) {
-    for (const t of tsutils.unionTypeParts(type)) {
+    for (const t of tsutils.unionConstituents(type)) {
         if (t.getCallSignatures().some(matcher)) {
             return true;
         }
@@ -372,7 +360,7 @@ function hasMatchingSignature(type, matcher) {
 }
 function isFunctionParam(checker, param, node) {
     const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
-    for (const t of tsutils.unionTypeParts(type)) {
+    for (const t of tsutils.unionConstituents(type)) {
         if (t.getCallSignatures().length !== 0) {
             return true;
         }

package/dist/rules/no-meaningless-void-operator.js

@@ -79,7 +79,7 @@ exports.default = (0, util_1.createRule)({
                     ]);
                 };
                 const argType = services.getTypeAtLocation(node.argument);
-                const unionParts = tsutils.unionTypeParts(argType);
+                const unionParts = tsutils.unionConstituents(argType);
                 if (unionParts.every(part => part.flags & (ts.TypeFlags.Void | ts.TypeFlags.Undefined))) {
                     context.report({
                         node,

package/dist/rules/no-misused-promises.js

@@ -551,7 +551,7 @@ exports.default = (0, util_1.createRule)({
 });
 function isSometimesThenable(checker, node) {
     const type = checker.getTypeAtLocation(node);
-    for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
         if (tsutils.isThenableType(checker, node, subType)) {
             return true;
         }
@@ -564,7 +564,7 @@ function isSometimesThenable(checker, node) {
 // branches is thenable.
 function isAlwaysThenable(checker, node) {
     const type = checker.getTypeAtLocation(node);
-    for (const subType of tsutils.unionTypeParts(checker.getApparentType(type))) {
+    for (const subType of tsutils.unionConstituents(checker.getApparentType(type))) {
         const thenProp = subType.getProperty('then');
         // If one of the alternates has no then property, it is not thenable in all
         // cases.
@@ -576,7 +576,7 @@ function isAlwaysThenable(checker, node) {
         // be of the right form to consider it thenable.
         const thenType = checker.getTypeOfSymbolAtLocation(thenProp, node);
         let hasThenableSignature = false;
-        for (const subType of tsutils.unionTypeParts(thenType)) {
+        for (const subType of tsutils.unionConstituents(thenType)) {
             for (const signature of subType.getCallSignatures()) {
                 if (signature.parameters.length !== 0 &&
                     isFunctionParam(checker, signature.parameters[0], node)) {
@@ -602,7 +602,7 @@ function isAlwaysThenable(checker, node) {
 }
 function isFunctionParam(checker, param, node) {
     const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, node));
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         if (subType.getCallSignatures().length !== 0) {
             return true;
         }
@@ -641,7 +641,7 @@ function voidFunctionArguments(checker, node) {
     const type = checker.getTypeAtLocation(node.expression);
     // We can't use checker.getResolvedSignature because it prefers an early '() => void' over a later '() => Promise<void>'
     // See https://github.com/microsoft/TypeScript/issues/48077
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         // Standard function calls and `new` have two different types of signatures
         const signatures = ts.isCallExpression(node)
             ? subType.getCallSignatures()
@@ -698,7 +698,7 @@ function anySignatureIsThenableType(checker, node, type) {
  * @returns Whether type is a thenable-returning function.
  */
 function isThenableReturningFunctionType(checker, node, type) {
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         if (anySignatureIsThenableType(checker, node, subType)) {
             return true;
         }
@@ -710,7 +710,7 @@ function isThenableReturningFunctionType(checker, node, type) {
  */
 function isVoidReturningFunctionType(checker, node, type) {
     let hadVoidReturn = false;
-    for (const subType of tsutils.unionTypeParts(type)) {
+    for (const subType of tsutils.unionConstituents(type)) {
         for (const signature of subType.getCallSignatures()) {
             const returnType = signature.getReturnType();
             // If a certain positional argument accepts both thenable and void returns,
@@ -729,7 +729,7 @@ function isVoidReturningFunctionType(checker, node, type) {
 function returnsThenable(checker, node) {
     const type = checker.getApparentType(checker.getTypeAtLocation(node));
     return tsutils
-        .unionTypeParts(type)
+        .unionConstituents(type)
         .some(t => anySignatureIsThenableType(checker, node, t));
 }
 function getHeritageTypes(checker, tsNode) {

package/dist/rules/no-misused-spread.js

@@ -97,7 +97,7 @@ exports.default = (0, util_1.createRule)({
             }
         }
         function getMapSpreadSuggestions(node, type) {
-            const types = tsutils.unionTypeParts(type);
+            const types = tsutils.unionConstituents(type);
             if (types.some(t => !isMap(services.program, t))) {
                 return null;
             }
@@ -208,7 +208,7 @@ exports.default = (0, util_1.createRule)({
 });
 function isIterable(type, checker) {
     return tsutils
-        .typeParts(type)
+        .typeConstituents(type)
         .some(t => !!tsutils.getWellKnownSymbolPropertyOfType(t, 'iterator', checker));
 }
 function isArray(checker, type) {

package/dist/rules/no-redundant-type-constituents.js

@@ -156,7 +156,7 @@ function describeLiteralTypeNode(typeNode) {
     return 'literal type';
 }
 function isNodeInsideReturnType(node) {
-    return !!(node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
+    return (node.parent.type === utils_1.AST_NODE_TYPES.TSTypeAnnotation &&
         (0, util_1.isFunctionOrFunctionType)(node.parent.parent));
 }
 /**
@@ -168,7 +168,7 @@ function unionTypePartsUnlessBoolean(type) {
         tsutils.isFalseLiteralType(type.types[0]) &&
         tsutils.isTrueLiteralType(type.types[1])
         ? [type]
-        : tsutils.unionTypeParts(type);
+        : tsutils.unionConstituents(type);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-redundant-type-constituents',

package/dist/rules/no-unnecessary-condition.js

@@ -44,14 +44,14 @@ function isNullishType(type) {
     return tsutils.isTypeFlagSet(type, nullishFlag);
 }
 function isAlwaysNullish(type) {
-    return tsutils.unionTypeParts(type).every(isNullishType);
+    return tsutils.unionConstituents(type).every(isNullishType);
 }
 /**
  * Note that this differs from {@link isNullableType} in that it doesn't consider
  * `any` or `unknown` to be nullable.
  */
 function isPossiblyNullish(type) {
-    return tsutils.unionTypeParts(type).some(isNullishType);
+    return tsutils.unionConstituents(type).some(isNullishType);
 }
 function toStaticValue(type) {
     // type.isLiteral() only covers numbers/bigints and strings, hence the rest of the branches.
@@ -198,13 +198,13 @@ exports.default = (0, util_1.createRule)({
         function nodeIsArrayType(node) {
             const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             return tsutils
-                .unionTypeParts(nodeType)
+                .unionConstituents(nodeType)
                 .some(part => checker.isArrayType(part));
         }
         function nodeIsTupleType(node) {
             const nodeType = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             return tsutils
-                .unionTypeParts(nodeType)
+                .unionConstituents(nodeType)
                 .some(part => checker.isTupleType(part));
         }
         function isArrayIndexExpression(node) {
@@ -223,7 +223,7 @@ exports.default = (0, util_1.createRule)({
         //    `any` or `unknown` or a naked type variable
         function isConditionalAlwaysNecessary(type) {
             return tsutils
-                .unionTypeParts(type)
+                .unionConstituents(type)
                 .some(part => (0, util_1.isTypeAnyType)(part) ||
                 (0, util_1.isTypeUnknownType)(part) ||
                 (0, util_1.isTypeFlagSet)(part, ts.TypeFlags.TypeVariable));

package/dist/rules/no-unnecessary-template-expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unnecessary-template-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-template-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBzD,MAAM,MAAM,SAAS,GAAG,iCAAiC,CAAC;;AAuB1D,wBAmbG"}
+{"version":3,"file":"no-unnecessary-template-expression.d.ts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-template-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAmBzD,MAAM,MAAM,SAAS,GAAG,iCAAiC,CAAC;;AAqB1D,wBAgbG"}

package/dist/rules/no-unnecessary-template-expression.js

@@ -43,7 +43,7 @@ const evenNumOfBackslashesRegExp = /(?<!(?:[^\\]|^)(?:\\\\)*\\)/;
 // '\\\\$' <- true
 // '\\\\\\$' <- false
 function endsWithUnescapedDollarSign(str) {
-    return new RegExp(`${String(evenNumOfBackslashesRegExp.source)}\\$$`).test(str);
+    return new RegExp(`${evenNumOfBackslashesRegExp.source}\\$$`).test(str);
 }
 exports.default = (0, util_1.createRule)({
     name: 'no-unnecessary-template-expression',
@@ -77,7 +77,7 @@ exports.default = (0, util_1.createRule)({
             return isStringLike(type);
         }
         function isEnumMemberType(type) {
-            return tsutils.typeParts(type).some(t => {
+            return tsutils.typeConstituents(type).some(t => {
                 const symbol = t.getSymbol();
                 return !!(symbol?.valueDeclaration && ts.isEnumMember(symbol.valueDeclaration));
             });
@@ -233,7 +233,7 @@ exports.default = (0, util_1.createRule)({
                         // \\` -> \\\`
                         // \${ -> \${
                         // \\${ -> \\\${
-                        .replaceAll(new RegExp(`${String(evenNumOfBackslashesRegExp.source)}(\`|\\\${)`, 'g'), '\\$1');
+                        .replaceAll(new RegExp(`${evenNumOfBackslashesRegExp.source}(\`|\\\${)`, 'g'), '\\$1');
                     // `...${'...$'}{...`
                     //           ^^^^
                     if (nextCharacterIsOpeningCurlyBrace &&

package/dist/rules/no-unnecessary-type-assertion.js

@@ -171,10 +171,10 @@ exports.default = (0, util_1.createRule)({
                 (0, util_1.isTypeFlagSet)(cast, ts.TypeFlags.Undefined) &&
                 tsutils.isCompilerOptionEnabled(compilerOptions, 'exactOptionalPropertyTypes')) {
                 const uncastParts = tsutils
-                    .unionTypeParts(uncast)
+                    .unionConstituents(uncast)
                     .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
                 const castParts = tsutils
-                    .unionTypeParts(cast)
+                    .unionConstituents(cast)
                     .filter(part => !(0, util_1.isTypeFlagSet)(part, ts.TypeFlags.Undefined));
                 if (uncastParts.length !== castParts.length) {
                     return false;