A way to define the opposite of Partial<T> type

[Deilan]

We already have Partial<T> and Readonly<T>, which are defined in the following way:

type Partial<T> = {
    [P in keyof T]?: T[P];
};

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

It would be great to have a way to define the opposite of Partial<T>, let's say Mandatory<T> or Strict<T>, etc.:

type Mandatory<T> = {
    [P in keyof T]: T[P]!;
    //                  ^
    // note an exclamation mark, which is already used for
    // asserting a var is not undefined nor null
};

Example. Let's say we have IPerson:

interface IPerson {
    name: string;
    age?: number;
}

Partial<IPerson> would look like that:

interface Partial<IPerson> {
    name?: string;
    age?: number;
}

And the Mandatory<IPerson>:

interface Mandatory<IPerson> {
    name: string;
    age: number;
}

[goodmind]

Looks like duplicate of #12936

[mhegazy]

This is actually a duplicate of #15012

[mhegazy]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.