# Bug Report: `Omit`-based assertion narrowing fails to override method return types on classes with private members

[deyaaeldeen]

🔎 Search Terms

asserts this is, Omit, private members, overload resolution, intersection, method return type, nominal typing, assertion narrowing

🕗 Version & Regression Information

• Tested on TypeScript 5.9.3, 5.4.5, and nightly
• This is the behavior in every version I tried

⏯ Playground Link

https://www.typescriptlang.org/play#code/JYOwLgpgTgZghgYwgAgEJwM4oN7JHAWwgC5kMwpQBzZAXwChRJZEUBRADzGQi4hAAmGNJhw8uUOKQBGAe1kAbCHBB1G4aPCRoIYOMlxEwAC1kCAFAEpSnMAG48EAO4B5AA5XSAN1nABa+gQFTGEAYQVgfm5semRkN0ovOEhkAH0OZABeZHgFLDtY5CNTC2sRLANkKF0AVyhVEBqFBQBCBwY4-jhpJVRdOE9kEOgwYRNgYQnkFwJgMAAecYwAGmQAImKzNYA+ZAAyHT0DBgZ6GBqQBDBgWVVIcisDQoRb8mQEUnDI8CzHJ2QvlErAU4ggAHRdHoQPp6YHPMEgZzuYFxVFouIAegx0wA0qREf9Nv4nLIoABrDDPV7cKC-cFEuFxKAQiRwBzojnILHINhQKCk0gAcl4FDgguQAlkEGEIFk3F4E24t2QYAAnm4UIL0FhBfRTtyAEoQAiyLwoNYJYBJFLpNZDQTIObIEnkjDEQLBDBhCJRFxkp5xBllbViapgOoNJqtdqFSG9fqDYZQUYq4xTKYzOaLNMrdZEnb7Q76bAnehnC5XG53aVgP2PGKg6nvT4+8B+34EgGt2tkxnvCH4KEwgaWEH9gnI0dUkBvWnZem6Ep95kiyTszlo7kuPFVaWKM1jWQ8rh6oA

💻 Code

interface Base { name: string }
interface Ext extends Base { extra: boolean }
interface Beta { method(): Ext; newOp(): void }

class Client {
  private _x = false;
  method(): Base { return null!; }
  enableBeta(): asserts this is Omit<this, "method"> & Beta {}
}

function test() {
  const c: Client = new Client();
  c.enableBeta();
  c.newOp();           // OK: new method works
  const r = c.method();
  r.extra;             // Error: 'extra' does not exist on type 'Base'
}

// Remove "private _x" and it works:
class ClientOk {
  method(): Base { return null!; }
  enableBeta(): asserts this is Omit<this, "method"> & Beta {}
}

function testOk() {
  const c: ClientOk = new ClientOk();
  c.enableBeta();
  c.newOp();
  const r = c.method();
  r.extra;             // OK: resolves to Ext
}

🙁 Actual behavior

After c.enableBeta(), the narrowed type of c is Client & Omit<Client, "method"> & Beta.

• New methods from Beta (e.g. newOp()) are accessible. ✅
• Calling c.method() resolves to return type Base (from the original class), not Ext (from Beta). ❌

The Omit<this, "method"> was intended to remove method from the class type so that the intersection with Beta provides the only method signature. Instead, overload resolution still picks the original class method.

🙂 Expected behavior

After assertion narrowing with asserts this is Omit<this, "method"> & Beta, calling c.method() should return Ext, since Omit was used to explicitly remove the original method signature.

Key observation: removing private fixes it

If the private _x field is removed, everything works correctly:

class ClientOk {
  // no private members
  method(): Base { return null!; }
  enableBeta(): asserts this is Omit<this, "method"> & Beta {}
}

function testOk() {
  const c: ClientOk = new ClientOk();
  c.enableBeta();
  const r = c.method();
  r.extra;             // ✅ works — resolves to Ext
}

Additional information about the issue

With private members, TypeScript treats the class nominally. In the narrowed intersection type Client & Omit<Client, "method"> & Beta:

1. Omit<Client, "method"> produces a mapped type that structurally removes method, but
2. The Client (nominal) part of the intersection still carries method(): Base
3. Beta adds method(): Ext
4. Overload resolution sees both signatures and picks the first match (from the nominal Client part), returning Base

Without private members, the class is structural, and Omit effectively removes method from the type, allowing Beta.method() to be the only match.

Additionally, at the type level, conditional type extraction does correctly resolve the return type:

type ExtractReturn<T> = T extends { method(): infer R } ? R : never;
type R = ExtractReturn<typeof c>;  // correctly resolves to Ext!

So the type system internally knows the correct answer, but call-site overload resolution disagrees.

Related issues:

• TS treats methods within type intersection as overloads instead of narrowing when parameters match  #53777 — Intersection methods treated as overloads ("first match wins") — closed as Working as Intended
• Return types of intersection of functions are incomplete and depend on order of declaration - an algorithm to fix it. #57095 — Return types of intersection functions are order-dependent — open suggestion
• Assertion Functions cannot assert over private properties - unnecessary/wrong error message? #47778 — Assertion functions cannot assert over private properties — open

[RyanCavanaugh]

This isn't a bug; both behaviors are working as designed.

Assertion narrowings can't cause a binding to become wider than its original type, so necessarily here, Client is in the narrowed type of c:

function test() {
  const c: Client = new Client();
  c.enableBeta();
  c.newOp();           // OK: new method works
//^? c: Client & Beta & Omit<...

Client needs to still be in the intersection, because otherwise c would be wider than its original declaration, e.g. if you had

  class Client {
    // ... others
    self(x: Client) { }

it needs to still be legal to call c.self(c); at this line, but that wouldn't be the case if Client weren't still intersected in. This in turn means that it still contributes its method overload, which gets selected by virtue of being first.

In the structural case, ClientOk can be simplified out of the intersection, so it doesn't contribute method anymore.

Basically one of three things would have to change for these to act the same, and each would break something else:

• Assertion methods could cause supertyping of the original declaration
• Change the order of intersection used during asserts is narrowing, which just causes this issue to manifest in the other direction instead
• Some other change in overload resolution that would necessarily break something; similar to changing the intersection order this would always have an observable dual form that previously worked but would start to fail

[khalidsaidi]

A2ABench has an accepted answer for this imported thread.

• Thread: https://a2abench-api.web.app/q/cmmpiccvv06g7tm95rz2xz1i2
• Accepted at: 2026-03-14T02:37:52.289Z
• Accepted answer agent: a2abench-mcp-proxy-python-httpx-563a83d61a937690
• Answer preview: "Analysis of the Bug This is a subtle but real issue in TypeScript's handling of type assertions involving Omit on classes with private members, combined with method overrides in intersections. Root Cause Classes with private members are treated nominally by the type system. Omit<"