diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
index 12a42398b3ee..5e1431f0cbce 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-condition.ts
@@ -530,7 +530,7 @@ export default createRule<Options, MessageId>({
           propertyType.value.toString(),
         );
         if (propType) {
-          return isNullableType(propType, { allowUndefined: true });
+          return isNullableType(propType);
         }
       }
       const typeName = getTypeName(checker, propertyType);
@@ -568,14 +568,12 @@ export default createRule<Options, MessageId>({
           );
 
           if (propType) {
-            return isNullableType(propType, { allowUndefined: true });
+            return isNullableType(propType);
           }
 
           return !!checker.getIndexInfoOfType(type, ts.IndexKind.String);
         });
-        return (
-          !isOwnNullable && isNullableType(prevType, { allowUndefined: true })
-        );
+        return !isOwnNullable && isNullableType(prevType);
       }
       return false;
     }
@@ -612,8 +610,7 @@ export default createRule<Options, MessageId>({
       const possiblyVoid = isTypeFlagSet(type, ts.TypeFlags.Void);
       return (
         isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown) ||
-        (isOwnNullable &&
-          (isNullableType(type, { allowUndefined: true }) || possiblyVoid))
+        (isOwnNullable && (isNullableType(type) || possiblyVoid))
       );
     }
 
diff --git a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
index be498cb94ad0..c688d75d2771 100644
--- a/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
+++ b/packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts
@@ -309,8 +309,7 @@ export default createRule<Options, MessageIds>({
       ): void {
         const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
         const type = checker.getTypeAtLocation(tsNode.left);
-        const isNullish = isNullableType(type, { allowUndefined: true });
-        if (!isNullish) {
+        if (!isNullableType(type)) {
           return;
         }
 
diff --git a/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts b/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts
index 8cf362938bab..d4d2e11b7b7d 100644
--- a/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts
+++ b/packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts
@@ -48,6 +48,11 @@ const foo = { 0: 'hello', 5: 'hello' } as PossibleTuple;
     `
 let bar: number | undefined = x;
 let foo: number = bar!;
+    `,
+    `
+declare const a: { data?: unknown };
+
+const x = a.data!;
     `,
     {
       code: `
diff --git a/packages/type-utils/src/predicates.ts b/packages/type-utils/src/predicates.ts
index 37658e31b716..26ef59355781 100644
--- a/packages/type-utils/src/predicates.ts
+++ b/packages/type-utils/src/predicates.ts
@@ -2,15 +2,18 @@ import debug from 'debug';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
-import { getTypeFlags, isTypeFlagSet } from './typeFlagUtils';
+import { isTypeFlagSet } from './typeFlagUtils';
 
 const log = debug('typescript-eslint:eslint-plugin:utils:types');
 
 export interface IsNullableTypeOptions {
   /**
-   * Whether the type is a receiving type (i.e. the type of a called function's parameter).
+   * @deprecated - this flag no longer does anything and will be removed in the next major
    */
   isReceiver?: boolean;
+  /**
+   * @deprecated - this flag no longer does anything and will be removed in the next major
+   */
   allowUndefined?: boolean;
 }
 
@@ -19,18 +22,15 @@ export interface IsNullableTypeOptions {
  */
 export function isNullableType(
   type: ts.Type,
-  { isReceiver = false, allowUndefined = true }: IsNullableTypeOptions = {},
+  _deprecated?: IsNullableTypeOptions,
 ): boolean {
-  const flags = getTypeFlags(type);
-
-  if (isReceiver && flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
-    return true;
-  }
-
-  if (allowUndefined) {
-    return (flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
-  }
-  return (flags & ts.TypeFlags.Null) !== 0;
+  return isTypeFlagSet(
+    type,
+    ts.TypeFlags.Any |
+      ts.TypeFlags.Unknown |
+      ts.TypeFlags.Null |
+      ts.TypeFlags.Undefined,
+  );
 }
 
 /**