refactor: use parameter properties where appropriate

src/api.ts

@@ -303,11 +303,11 @@ class Api {
                             resolve(
                                 result.data.data.items.map(
                                     (workspace: WorkspaceProtocol) =>
-                                        new Workspace({
-                                            api: this,
-                                            definition: workspace.definition,
-                                            id: workspace.id,
-                                        })
+                                        new Workspace(
+                                            this,
+                                            workspace.definition,
+                                            workspace.id
+                                        )
                                 )
                             )
                         )
@@ -386,11 +386,11 @@ class Api {
                         )
                         .then((response) =>
                             resolve(
-                                new Workspace({
-                                    api: this,
-                                    definition: response.data.definition,
-                                    id: response.data.id,
-                                })
+                                new Workspace(
+                                    this,
+                                    response.data.definition,
+                                    response.data.id
+                                )
                             )
                         )
                         .catch((e) => reject(toApiError(e)))
@@ -561,11 +561,11 @@ class Api {
                             resolve(
                                 result.data.data.items.map(
                                     (project: LocalProjectProtocol) =>
-                                        new Project({
-                                            api: this,
-                                            id: project.id,
-                                            workspaceId,
-                                        })
+                                        new Project(
+                                            this,
+                                            project.id,
+                                            workspaceId
+                                        )
                                 )
                             )
                         )

src/case.ts

@@ -10,35 +10,14 @@ import Api from './api'
 import ModelExecutable from './model-executable'
 
 class Case {
-    private api: Api
-    private experimentId: ExperimentId
-    private fmuId?: FmuId
-    id: CaseId
-    runInfo: CaseRunInfo
-    private workspaceId: WorkspaceId
-
-    constructor({
-        api,
-        experimentId,
-        fmuId,
-        id,
-        runInfo,
-        workspaceId,
-    }: {
-        api: Api
-        id: CaseId
-        fmuId?: FmuId
-        experimentId: ExperimentId
-        runInfo: CaseRunInfo
-        workspaceId: WorkspaceId
-    }) {
-        this.api = api
-        this.fmuId = fmuId
-        this.id = id
-        this.runInfo = runInfo
-        this.experimentId = experimentId
-        this.workspaceId = workspaceId
-    }
+    constructor(
+        private api: Api,
+        public id: CaseId,
+        private experimentId: ExperimentId,
+        public runInfo: CaseRunInfo,
+        private workspaceId: WorkspaceId,
+        private fmuId?: FmuId
+    ) {}
 
     getInput = () =>
         this.api.getCaseInput({

src/execution-status.ts

@@ -1,11 +1,7 @@
 import { ExecutionStatusType } from './types'
 
 class ExecutionStatus {
-    status: ExecutionStatusType
-
-    constructor(status: ExecutionStatusType) {
-        this.status = status
-    }
+    constructor(public status: ExecutionStatusType) {}
 
     getNbrCompilationDone = () =>
         this.status?.progresses?.filter(

src/experiment.ts

@@ -49,14 +49,14 @@ class Experiment {
 
         return casesResponse.map(
             (caseResponse, i) =>
-                new Case({
-                    api: this.api,
-                    experimentId: this.id,
-                    fmuId: caseResponse.input.fmu_id,
-                    id: caseResponse.id || i.toString(),
-                    runInfo: caseResponse.run_info,
-                    workspaceId: this.workspaceId,
-                })
+                new Case(
+                    this.api,
+                    caseResponse.id || i.toString(),
+                    this.id,
+                    caseResponse.run_info,
+                    this.workspaceId,
+                    caseResponse.input.fmu_id
+                )
         )
     }
 

src/model-description.ts

@@ -11,11 +11,7 @@ type ModelDescriptionData = {
 }
 
 class ModelDescription {
-    private data: ModelDescriptionData
-
-    constructor(data: ModelDescriptionData) {
-        this.data = data
-    }
+    constructor(private data: ModelDescriptionData) {}
 
     getDefaultExperiment() {
         const defaultExperiment = this.data.DefaultExperiment

src/model.ts

@@ -1,9 +1,6 @@
 import { CustomFunctionOptions, ModelDefinition } from './types'
 
 class Model {
-    customFunctionOptions?: CustomFunctionOptions
-    private model: ModelDefinition
-
     private static DefaultModelicaModelContent = {
         compilerLogLevel: 'warning',
         compilerOptions: {
@@ -15,16 +12,10 @@ class Model {
         runtimeOptions: {},
     }
 
-    private constructor({
-        customFunctionOptions,
-        model,
-    }: {
-        customFunctionOptions?: CustomFunctionOptions
-        model: ModelDefinition
-    }) {
-        this.customFunctionOptions = customFunctionOptions
-        this.model = model
-    }
+    private constructor(
+        private model: ModelDefinition,
+        public customFunctionOptions?: CustomFunctionOptions
+    ) {}
 
     static from({
         className,
@@ -33,14 +24,14 @@ class Model {
         className: string
         customFunctionOptions?: CustomFunctionOptions
     }) {
-        return new Model({
-            customFunctionOptions,
-            model: { modelica: { className } } as ModelDefinition,
-        })
+        return new Model(
+            { modelica: { className } } as ModelDefinition,
+            customFunctionOptions
+        )
     }
 
     static fromModelDefinition(model: ModelDefinition) {
-        return new Model({ model })
+        return new Model(model)
     }
 
     toModelDefinition() {

src/project.ts

@@ -4,23 +4,11 @@ import Experiment from './experiment'
 import ExperimentDefinition from './experiment-definition'
 
 class Project {
-    private api: Api
-    id: ProjectId
-    private workspaceId: WorkspaceId
-
-    constructor({
-        api,
-        id,
-        workspaceId,
-    }: {
-        api: Api
-        id: ProjectId
-        workspaceId: WorkspaceId
-    }) {
-        this.api = api
-        this.id = id
-        this.workspaceId = workspaceId
-    }
+    constructor(
+        private api: Api,
+        public id: ProjectId,
+        private workspaceId: WorkspaceId
+    ) {}
 
     getExperiments = async () => {
         const experimentItems = await this.api.getProjectExperiments({

src/workspace.ts

@@ -14,23 +14,11 @@ import ModelExecutable from './model-executable'
 import Project from './project'
 
 class Workspace {
-    private api: Api
-    id: WorkspaceId
-    definition: WorkspaceDefinition
-
-    constructor({
-        api,
-        definition,
-        id,
-    }: {
-        api: Api
-        definition: WorkspaceDefinition
-        id: WorkspaceId
-    }) {
-        this.api = api
-        this.definition = definition
-        this.id = id
-    }
+    constructor(
+        private api: Api,
+        public definition: WorkspaceDefinition,
+        public id: WorkspaceId
+    ) {}
 
     private createExperiment = async (
         experimentDefinition: ExperimentDefinition