If your intention is to track specific values in elements such as requiredFields and optionalFields within a Model, it might be advantageous to make the Model more generic in these types. One approach could be structuring it as Model<R, O>, where R includes all essential keys and O covers optional keys.

However, incorporating type R and keys of O into a Model<R, O> can pose challenges with standard class declarations. Classes and interfaces require known keys statically to the compiler and do not support dynamic or late filling:

class Foo<T extends object > ; implements T {} // error!
// -----------------------------------> ~
// A class can only implement an object type or intersection 
// of object types with statically known members.

Hence, finding a workaround becomes crucial.

---

A practical method involves defining a class constructor type like so:

type ModelConstructor = new <R extends string, O extends string>(
    params: ModelObject<R, O>
) => ModelObject<R, O> & {
    set(params: Partial<ModelObject<R, O>>): void,
    all_fields: Array<R | O>;
    required_fields: R[];
}

type ModelObject<R extends string, O extends string> =
    Record<R, string> & Partial<Record<O, string>>;

The construct signature within ModelConstructor accepts a params of type ModelObject<R, O>. This ModelObject<R, O> defines an object type with mandatory keys R and optional keys

O</code, where all values are strings. The instance created aligns with <code>ModelObject<R, O>

intersected with properly typed properties and methods inside your Model class.

Prior to proceeding further, consider how to subclass Model. If each instance of, for example, User, requires the same required and optional fields, converting Model into a class factory function instead of a class constructor may be beneficial. Otherwise, you would need to redundantly specify R and

O</code:</p>
<pre><code>class AnnoyingUser extends Model<"username", "email"> {
    _required_fields = ["username"] // redundant
    _optional_fields = ["email"] // redundant
}

An alternate method that streamlines this process is:

class User extends Model(["username"], ["email"]) { }

In this scenario, Model(["username"], ["email"]) constructs a preloaded class with those specified fields. The decision to adopt this approach is subjective. Assuming acceptance of a factory function, let's continue using it.

---

Here is the implementation of the factory function:

export const Model = <R extends string, O extends string>(
    requiredFields: R[], optionalFields: O[]
) => {

    type ModelObject =
        Record<R, string> & Partial<Record<O, string>> extends
        infer T ? { [K in keyof T]: T[K] } : never;

    class _Model {
        _required_fields: Array<R> = requiredFields;
        _optional_fields?: Array<O> = optionalFields;

        constructor(params: ModelObject) {
            this.set(params);
        }

        set(params: Partial<ModelObject>) {
            this.all_fields.forEach(key => {
                (this as any)[key] = (params as any)[key];
            });
        }

        get all_fields(): Array<R | O> {
            return [...this._required_fields,
            ...this._optional_fields ?? []];
        }

        get required_fields() {
            return this._required_fields;
        }
    }

    return _Model as any as new (params: ModelOb...</answer1></answer1>
<exanswer1><div class="answer accepted" i="69597918" l="4.0" c="1634393867" m="1634409966" v="1" a="amNhbHo=" ai="2887218">
<p>If you are looking to configure <code>Model to oversee the explicit values in elements like requiredFields and optionalFields, customizing Model to be generic in these types could be beneficial. Consider utilizing a structure like Model<R, O>, where R merges all essential keys and O</code encompasses the optional keys.</p>
<p>However, ensuring that a <code>Model<R, O> effectively includes type R and keys of O</code poses challenges with traditional <code>class declarations. Classes and interfaces necessitate known keys statically to the compiler and cannot allow for dynamic or late filling:

class Foo<T extends object > implements T {} // error!
// -----------------------------------> ~
// A class can only implement an object type or intersection 
// of object types with statically known members.

Therefore, finding a workaround is crucial.

One practical approach involves defining a class constructor type as follows:
type ModelConstructor = new <R extends string, O extends string>(
    params: ModelObject<R, O>
) => ModelObject<&g...ny necessary static properties of the returned class constructor.  I am not going to delve into that.  Just food for thought.</p>
<hr />
<p>Let's give it a try. First, let's see what happens when we call <code>Model:

const UserModel = Model(["username"], ["email"]);
/* const UserModel: new (params: {
    username: string;
    email?: string | undefined;
}) => {
    username: string;
    email?: string | undefined;
    set: (params: Partial<{...
} */

Seems reasonable and aligned with your requirements. Next, we can define the User class:
export class User extends Model(["username"], ["email"]) {
    // static REQUIRED_FIELDS = ['username'];
    // static OPTIONAL_FIELDS = ['email'];
}

The commented out static properties were from your initial example, but they are unnecessary in my solution. You can always include them back if needed, although their purpose remains unclear.
Now, let's test it out:
const u = new User({ username: "alice" });
console.log(u.required_fields); // ["username"]
console.log(u.all_fields); // ["username", "email"]
u.set({ email: "<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="20646d6d52677a636f727e774c010d0f">[email protected]</a>" });
console.log(u.email); // <a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="3e7c757552777a63655b64665741647b53570b6656585a">[email protected]</a>

Looks good!
Playground link to code