Post History

The existing answer is fine, but you can achieve similar results in many ways using some of [TypeScript's utility types](https://www.typescriptlang.org/docs/handbook/utility-types.html).

### `Required<T>`

While you cannot use (only) `Partial` to do this, TypeScript provides the opposite `Required` as well - so if one of your types requires all properties, you can start by defining the one with some optional ones:

```typescript
type UserForClients = {
   name: string;
   superSecretGovernmentIdNumber?: string;
};

type UserForServers = Required<UserForClients>;
```

### `Partial<T>` and (`Omit<T, K>` or `Pick<T, K>`)
Going in the other direction, starting with a "base" type and making some properties optional. `Partial` makes everything optional, but by combining it with parts of the base type that still require some properties, we can "cancel" the optionality:

```typescript
type UserForServers = {
    name: string;
    superSecretGovernmentIdNumber: string;
};

type UserForClients = Partial<UserForServers> & Omit<UserForServers, "superSecretGovernmentIdNumber">;

// Or, equivalently

type UserForClients = Partial<UserForServers> & Pick<UserForServers, "name">;
```

### Custom Utility types

We can create some utility types of our own to handle these cases if they are frequent:

```typescript
type WithOptional<T, K extends keyof T> = Partial<T> & Omit<T, K>;

type UserForServer = {
   name: string;
   superSecretGovernmentIdNumber: string;
};

type UserForClient = WithOptional<UserForServer, "superSecretGovermentIdNumber">;

// Or, equivalently

type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;

type UserForClient = {
    name: string;
    superSecretGovernmentIdNumber?: string;
};

type UserForServer = WithRequired<UserForClient, "superSecretGovernmentIdNumber">;
```