Keep private field type

I have a somewhat strange case where I need a class property merely to hold on to a generic type and not because I want to access it at runtime.

I have a class and utility type like this:

class Foo<T> {
    private _dummy!: T;
}

type UnwrapFoo<T extends Foo<any>> = T extends Foo<infer Unwrapped> ? Unwrapped : never;

The property _dummy is never accessed in any way, but it is required for UnwrapFoo to work. Otherwise, were it not present, T would be discarded meaning that UnwrapFoo can not infer it anymore.

My issue is that, when TypeScript generates the respective .d.ts file, it erases the type of _dummy, as it is a private property. The generated typings look like this:

class Foo<T> {
    private _dummy;
}

Now, T is being discarded again and UnwrapFoo ceases to work. Is there a good way to keep the type of _dummy? I could make it public, but I do not like that because it is purely an internal property that should never be accessed by a user of the Foo class (also, it is always undefined anyway, despite what its type says).

It doesn't seem to be well-documented, but the types of private class properties are intentionally suppressed from .d.ts files generated via the --declaration compiler option, and there's no way to change that. In terms of official documentation, I only see this comment in a related GitHub issue, and the fact that the declaration emitter source code actively suppresses type annotation for private things except in constructor parameter properties.

Assuming you need to keep a dummy field for this purpose and you don't want it accessible from the outside in general, you might consider changing it to a protected property instead:

// foo.ts
class Foo<T> {
    declare protected _dummy: T;
}

// foo.d.ts
declare class Foo<T> {
    protected _dummy: T;
}

This isn't as private as private, since someone could come along and subclass it, but at least people won't be tempted to access that member on an instance.

Playground link to code

So in general keep in mind that types in TypeScript do not generate and JavaScript code, they are metadata only for you and the compiler to know about as you write code. Because of this, types cannot be saved to variables.

Regarding the generation of the .d.ts files, keep in mind that the type is not present because the property is private. Nothing outside the class can access it, so putting a type on it for a type definition file is useless. Consider the following:

class Foo {
    private _dummy: string = '';
}

The generated .d.ts file is as follows:

declare class Foo {
    private _dummy;
}

However, a public property will have type information since other things that use the .d.ts file will have access to a public property.

class Foo {
    public _dummy: string = '';
}

The generated .d.ts file is as follows:

declare class Foo {
    _dummy: string;
}