Using a TypeScript interface instead of a class can simplify things:

export interface Employee {
    typeOfEmployee_id: number;
    department_id: number;
    permissions_id: number;
    maxWorkHours: number;
    employee_id: number;
    firstname: string;
    lastname: string;
    username: string;
    birthdate: Date;
    lastUpdate: Date;
}

let jsonObj = JSON.parse(employeeString); // convert string to "any" object first
let employee = jsonObj as Employee;

However, if you prefer using a class, simple casting may not work as expected. For instance:

class Foo {
    name: string;
    public pump() { }
}

let jsonObj = JSON.parse('{ "name":"hello" }');
let fObj = jsonObj as Foo;
fObj.pump(); // throws an error, method is undefined!

When dealing with a class, you'll need to manually assign properties by writing a constructor that takes a JSON string/object and iterates through the properties like so:

class Foo {
    name: string;

    constructor(jsonStr: string) {
        let jsonObj = JSON.parse(jsonStr);
        for (let prop in jsonObj) {
            this[prop] = jsonObj[prop];
        }
    }
}

let fObj = new Foo(theJsonString);

const worker = <Worker>JSON.parse(employeeString);

It is important to note that strong typings are only enforced during compile time in JavaScript due to the lack of native support for it.

If your JSON data contains properties not present in your class, you can create a custom mapping to handle them.

export class Employee { ////
    static parse(json: string) {
           var data = JSON.parse(json);
            return new Employee(data.employeeType_id, data.firstName.. and more);
       }
}

You can also define a constructor within your Employee class for more precise mapping.

One of my favorite small libraries that I enjoy using is class-transformer.

This library has the capability to manage nested objects, convert strings into date objects, and handle different JSON property names efficiently.

If you haven't already, it may be worth checking out.

import { Type, plainToClass, Expose } from "class-transformer";
import 'reflect-metadata';

export class Employee {
    @Expose({ name: "uid" })
    id: number;

    firstname: string;
    lastname: string;
    birthdate: Date;
    maxWorkHours: number;
    department: string;

    @Type(() => Permission)
    permissions: Permission[] = [];
    typeOfEmployee: string;
    note: string;

    @Type(() => Date)
    lastUpdate: Date;
}

export class Permission {
    type: string;
}

let json: string = {
    "uid": 123,
    "department": "<anystring>",
    "typeOfEmployee": "<anystring>",
    "firstname": "<anystring>",
    "lastname": "<anystring>",
    "birthdate": "<anydate>",
    "maxWorkHours": 1,
    "username": "<anystring>",
    "permissions": [
        {'type': 'read'},
        {'type': 'write'}
    ],
    "lastUpdate": "2020-05-08"
}

console.log(plainToClass(Employee, json));

To start, it is important to confirm that all attributes received from the service have matching names in your class. You can then parse the object and assign it to a new variable, as shown below:

const parsedData = JSON.parse(apiResponse);
const userObject: User = parsedData as User;

Give it a try!

Consider implementing the constructor method in your class.

Object.assign

is a crucial aspect.

Here is an example for your reference:

class Employee{
    firstname: string;
    lastname: string;
    birthdate: Date;
    maxWorkHours: number;
    department: string;
    permissions: string;
    typeOfEmployee: string;
    note: string;
    lastUpdate: Date;

    constructor(original: Object) { 
        Object.assign(this, original);
    }
}

let e = new Employee({
    "department": "<anystring>",
    "typeOfEmployee": "<anystring>",
    "firstname": "<anystring>",
    "lastname": "<anystring>",
    "birthdate": "<anydate>",
    "maxWorkHours": 3,
    "username": "<anystring>",
    "permissions": "<anystring>",
    "lastUpdate": "<anydate>"
});
console.log(e);

If you want to convert the JSON data into a specific class instance, you can follow these steps:

Assuming you have the following class structure:

export class Person{
    name: string= '';
}

and the JSON object:

let personObj = {
    "name": "Alice"
};

You can perform the conversion like this:

let p: Person = personObj as Person;

The result of console.log(p); will be:

{ name: 'Alice' }

One way to achieve this is by creating a new instance of your class and dynamically assigning its parameters from the JSON object.

const employeeData = JSON.parse(employeeString);
let emp:Employee=new Employee();
const keys=Object.keys(employeeData);
keys.forEach(key=>{
    emp[key]=employeeData[key];
});
console.log(emp);

At this point, 'emp' will be an object of type Employee that contains all the fields from the JSON object stored in 'employeeData'.

Is it possible to execute this task using the keyword "as" in the syntax?

async fetchContact(): Promise<Individual> {
      const accessUrl: string = this.baseApi;
    
      const result = await this.http.get(accessUrl).toPromise()
      return JSON.parse(result.json()) as Individual;
    }

Here is a streamlined approach that is effective for basic "flat" objects:

const updatedObjectList = originalObjectList.map(obj => Object.assign(new ObjectType(), obj));

After applying this transformation, you can easily utilize the methods associated with objects defined in the ObjectType class.