Repository: TypeScript
Issue: Extend mapped types/default type utils, for better type from class experience
Labels: Suggestion,Awaiting More Feedback

# Suggestion

## 🔍 Search Terms

get, set, mapped types, remove getters from type, remove setters from type, get public fields only from class

## ✅ Viability Checklist

My suggestion meets these guidelines:

- [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [x] This wouldn't change the runtime behavior of existing JavaScript code
- [x] This could be implemented without emitting different JS based on the types of the expressions
- [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).

## ⭐ Suggestion

Being able to remove/collect keys of `get` `set` types using Mapped Types syntax + many other utils to make types from class definitions based on their access level, type, return type, etc.

## 📃 Motivating Example

Basically, I have classes everywhere and I want to generate for it a default constructor that is taken from `BaseClass` that takes all the fields passed and assigns them to the fields of the class.

E.g.

```ts
abstract class BaseClass {
  constructor(fields: Record<string, unknown>) {
    for (const field in fields) {
      this[field] = fields[field];
    }
  }
}
```

That then gets extended.

```ts
class User extends BaseClass {
     constructor(
    fields: DefaultConstructorFields<User>
  ) {
    super(fields)
  }
  firstName: string
  secondName: string

  get fullName(): string {
     return this.firstName + " " + this.secondName
  }

  set fullName(full: string) { ... }
}
```

Something like

```ts
type RemoveGetters<Type> = {
  -get [Property in keyof Type]: Type[Property];
};

type RemoveSetters<Type> = {
  -set [Property in keyof Type]: Type[Property];
};
```

And some "magic" type utils like `PublicFields<ClassName>` `PrivateFields<ClassName` or maybe some special syntax to do such things on `class` definitions to get plain `type` will be awesome.

Problem is that I cannot make type util e.g. that `DefaultConstructorFields`, that will ignore all function fields, get fields, replace set with just whatever comes as an argument to the setter.

Currently, it's possible to filter functions/read-only fields/based on type/name, but not `get` and `set`, or filter by field visibility such as `public` `protected` `private` and ES6 private `#field`. Only manual `Omit` is possible.

## 💻 Use Cases

Ideally, I want to have my default constructors up and running with minimal overhead. E.g. like Kotlin has `data class` that just generates POJO with default constructor/hashCode/equals etc. while still allowing for `get` for calculated properties and `set` for setting things up while initializing the instance through the constructor.

So my main use case is strict Model classes (typeorm in my case) with lots of annotations and GraphQL Types that are still classes, because it's how Nest.js GraphQL works, it needs a runtime class e.g. prototype to defer the type at runtime.