@dnv-plant/typescriptpws 1.0.86 → 1.0.88

package/src/calculations/discharge.ts

@@ -6,12 +6,10 @@
 * Editing it may lead to inconsistent results and limit DNV's ability to provide support.
 * Please contact DNV if you believe changes are required.
 *
-* Version:   1.0.86
-* Date/time: 10 Jul 2025 09:49:06
+* Version:   1.0.89
+* Date/time: 29 Jul 2025 17:59:11
 * Template:  templates/typescriptpws/calculations.razor.
- ***********************************************************************/
-
-
+***********************************************************************/
 
 import * as Enums from "../enums";
 import * as Entities from "../entities";
@@ -36,12 +34,17 @@ class CalculationBase {
   messages: string[] = [];
   calculationElapsedTime?: number = 0.0;
   operationId?: string = "";
+  controller?: AbortController;
+
+  constructor(controller?: AbortController) {
+    this.controller = controller;
+  }
 
   /**
    * Post JSON to URL and time the call
    */
   async postRequest(url: string, data: string): Promise<AxiosResponse> {
-    return postRequest(url, data);
+    return postRequest(url, data, this.controller);
   }
 
   /**
@@ -153,6 +156,234 @@ class CalculationFailedResponseSchema {
   }
   }
     
+export interface BESSConfidenceIntervalEnergyScalingCalculationRequestSchemaData {
+  chemistry: number;
+  confidenceInterval: number;
+}
+
+class BESSConfidenceIntervalEnergyScalingCalculationRequest extends CalculationRequestBase {
+  chemistry: number;
+  confidenceInterval: number;
+
+  /**
+   * BESSConfidenceIntervalEnergyScaling calculation request class.
+   *
+   */
+  constructor(data: {
+    chemistry: number,
+    confidenceInterval: number
+  }) {
+    super();
+    this.chemistry = data.chemistry;
+    this.confidenceInterval = data.confidenceInterval;
+  }
+}
+
+export class BESSConfidenceIntervalEnergyScalingCalculationRequestSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the BESSConfidenceIntervalEnergyScaling calculation request.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      chemistry: Joi.number().integer(),
+      confidenceInterval: Joi.number().unsafe(),
+    }).unknown(true);
+
+    this.propertyTypes = {
+      chemistry: "number",
+      confidenceInterval: "number",
+    };
+  }
+
+  validate(data: BESSConfidenceIntervalEnergyScalingCalculationRequestSchemaData): BESSConfidenceIntervalEnergyScalingCalculationRequest {
+    const { error, value } = this.schema.validate(data, { abortEarly: false });
+    if (error) {
+      throw new Error(`Validation error: ${error.details.map((x) => x.message).join(", ")}`);
+    }
+    return this.makeCalculationRequest(value);
+  }
+
+  makeCalculationRequest(data: BESSConfidenceIntervalEnergyScalingCalculationRequestSchemaData): BESSConfidenceIntervalEnergyScalingCalculationRequest {
+    return new BESSConfidenceIntervalEnergyScalingCalculationRequest(data);
+  }
+}
+
+export class BESSConfidenceIntervalEnergyScalingCalculation extends CalculationBase {
+  chemistry: number;
+  confidenceInterval: number;
+  kUpper?: number;
+  kLower?: number;
+
+  /**
+   *  Confidence interval scaling values for a BESS calculation.
+   *
+   */
+  constructor(data: {
+    chemistry: number,
+    confidenceInterval: number
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.chemistry = data.chemistry;
+    this.confidenceInterval = data.confidenceInterval;
+  }
+
+  async run() {
+    try {
+      const request = new BESSConfidenceIntervalEnergyScalingCalculationRequest({
+        chemistry: this.chemistry,
+        confidenceInterval: this.confidenceInterval
+      });
+
+      const schema = new BESSConfidenceIntervalEnergyScalingCalculationRequestSchema();
+      const validatedRequest = schema.validate(request);
+
+      const requestJson = JSON.stringify(validatedRequest);
+      const url = `${getAnalyticsApiTarget()}calculatebessconfidenceintervalenergyscaling?clientId=${getClientAliasId()}`;
+
+      this.resultCode = Enums.ResultCode.UNEXPECTED_APPLICATION_ERROR;
+
+      const { data } = await this.postRequest(url, requestJson);
+
+      const responseSchema = new BESSConfidenceIntervalEnergyScalingCalculationResponseSchema();
+      const validatedResponse = responseSchema.validate(data);
+
+      this.resultCode = validatedResponse.resultCode;
+      if (this.resultCode === Enums.ResultCode.SUCCESS) {
+        Object.assign(this, {
+          kUpper: validatedResponse.kUpper,
+          kLower: validatedResponse.kLower,
+          resultCode: validatedResponse.resultCode,
+          messages: validatedResponse.messages ?? [],
+          calculationElapsedTime: validatedResponse.calculationElapsedTime,
+          operationId: validatedResponse.operationId,
+        });
+      } else {
+        this.messages.push(...(validatedResponse.messages ?? []));
+      }
+    } catch (err: any) {
+      if ((err as any)?.response) {
+        this.handleFailedResponse((err as any).response);
+      } else {
+        throw err;
+      }
+      console.error(err);
+    }
+
+    return this.resultCode;
+  }
+
+  toString() {
+    const parts = ["* BESSConfidenceIntervalEnergyScaling"];
+
+    parts.push(`kUpper: ${String(this.kUpper)}`);
+    parts.push(`kLower: ${String(this.kLower)}`);
+    parts.push(`resultCode: ${String(this.resultCode)}`);
+    parts.push("*** messages:");
+    parts.push(`messages: ${this.messages !== undefined ? this.messages : "(None)"}`);
+    parts.push(`calculationElapsedTime: ${this.calculationElapsedTime !== undefined ? this.calculationElapsedTime : "(None)"}`);
+    parts.push(`operationId: ${this.operationId !== undefined ? this.operationId : "(None)"}`);
+
+    return parts.join("\n");
+  }
+}
+
+export class BESSConfidenceIntervalEnergyScalingCalculationResponse extends CalculationResponseBase {
+  kUpper: number;
+  kLower: number;
+
+  /**
+   * BESSConfidenceIntervalEnergyScaling calculation response class.
+   *
+   */
+  constructor(data: {
+    kUpper: number,
+    kLower: number,
+    resultCode: Enums.ResultCode,
+    messages: string[],
+    calculationElapsedTime: number,
+    operationId: string
+  }) {
+    super();
+    this.kUpper = data.kUpper;
+    this.kLower = data.kLower;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
+  }
+
+  initialiseFromDictionary(data: { [key: string]: unknown }) {
+    if (data.kUpper !== undefined && typeof data.kUpper === "number") {
+      this.kUpper = data.kUpper as number;
+    }
+    if (data.kLower !== undefined && typeof data.kLower === "number") {
+      this.kLower = data.kLower as number;
+    }
+    if (data.resultCode !== undefined && (typeof data.resultCode === "string" || typeof data.resultCode === "number")) {
+      this.resultCode = data.resultCode as Enums.ResultCode;
+    }
+    this.messages = this.messages ?? [];
+    if (data.messages && Array.isArray(data.messages)) {
+      this.messages.push(...data.messages);
+    }
+    if (data.calculationElapsedTime !== undefined && typeof data.calculationElapsedTime === "number") {
+      this.calculationElapsedTime = data.calculationElapsedTime as number;
+    }
+    if (data.operationId !== undefined && typeof data.operationId === "string") {
+      this.operationId = data.operationId as string;
+    }
+  }
+}
+
+export interface BESSConfidenceIntervalEnergyScalingCalculationResponseSchemaData {
+  kUpper: number;
+  kLower: number;
+  resultCode: Enums.ResultCode;
+  messages: string[];
+  calculationElapsedTime: number;
+  operationId: string;
+}
+
+export class BESSConfidenceIntervalEnergyScalingCalculationResponseSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the BESSConfidenceIntervalEnergyScaling calculation response.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      kUpper: Joi.number().unsafe(),
+      kLower: Joi.number().unsafe(),
+      resultCode: Joi.string().valid(...Object.values(Enums.ResultCode)),
+      messages: Joi.array().items(Joi.string()),
+      calculationElapsedTime: Joi.number().unsafe(),
+      operationId: Joi.string().uuid().allow(null),
+    }).unknown(true);
+
+    this.propertyTypes = {
+      kUpper: "number",
+      kLower: "number",
+    };
+  }
+
+  validate(data: BESSConfidenceIntervalEnergyScalingCalculationResponseSchemaData): BESSConfidenceIntervalEnergyScalingCalculationResponse {
+    const { error, value } = this.schema.validate(data, { abortEarly: false });
+    if (error) {
+      throw new Error(`Validation error: ${error.details.map((x) => x.message).join(", ")}`);
+    }
+    return this.makeCalculationResponse(value);
+  }
+
+  makeCalculationResponse(data: BESSConfidenceIntervalEnergyScalingCalculationResponseSchemaData): BESSConfidenceIntervalEnergyScalingCalculationResponse {
+    return new BESSConfidenceIntervalEnergyScalingCalculationResponse(data);
+  }
+}
+
 export interface BESSToxicSourceCalculationRequestSchemaData {
   bessUnit: Entities.BESSUnit;
   bessRelease: Entities.BESSRelease;
@@ -165,16 +396,14 @@ class BESSToxicSourceCalculationRequest extends CalculationRequestBase {
   /**
    * BESSToxicSource calculation request class.
    *
-   * @param {Entities.BESSUnit} bessUnit - BESS unit under thermal runaway.
-   * @param {Entities.BESSRelease} bessRelease - Specifics of the release from the unit being considered.
    */
-  constructor(
+  constructor(data: {
     bessUnit: Entities.BESSUnit,
     bessRelease: Entities.BESSRelease
-  ) {
+  }) {
     super();
-    this.bessUnit = bessUnit;
-    this.bessRelease = bessRelease;
+    this.bessUnit = data.bessUnit;
+    this.bessRelease = data.bessRelease;
   }
 }
 
@@ -206,10 +435,7 @@ export class BESSToxicSourceCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: BESSToxicSourceCalculationRequestSchemaData): BESSToxicSourceCalculationRequest {
-    return new BESSToxicSourceCalculationRequest(
-      data.bessUnit,
-      data.bessRelease
-    );
+    return new BESSToxicSourceCalculationRequest(data);
   }
 }
 
@@ -223,24 +449,23 @@ export class BESSToxicSourceCalculation extends CalculationBase {
   /**
    *  Toxic outflow from a BESS unit.
    *
-   * @param {Entities.BESSUnit} bessUnit - BESS unit under thermal runaway.
-   * @param {Entities.BESSRelease} bessRelease - Specifics of the release from the unit being considered.
    */
-  constructor(
+  constructor(data: {
     bessUnit: Entities.BESSUnit,
     bessRelease: Entities.BESSRelease
-  ) {
-    super();
-    this.bessUnit = bessUnit;
-    this.bessRelease = bessRelease;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.bessUnit = data.bessUnit;
+    this.bessRelease = data.bessRelease;
   }
 
   async run() {
     try {
-      const request = new BESSToxicSourceCalculationRequest(
-        this.bessUnit,
-        this.bessRelease
-      );
+      const request = new BESSToxicSourceCalculationRequest({
+        bessUnit: this.bessUnit,
+        bessRelease: this.bessRelease
+      });
 
       const schema = new BESSToxicSourceCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -310,11 +535,8 @@ export class BESSToxicSourceCalculationResponse extends CalculationResponseBase
   /**
    * BESSToxicSource calculation response class.
    *
-   * @param {Entities.Material} bessMaterial - Composition of the released material (dependent on batter chemistry).
-   * @param {Entities.DischargeResult} dischargeResult - Scalar discharge results.
-   * @param {Entities.DischargeRecord[]} dischargeRecords - Array of discharge records.
    */
-  constructor(
+  constructor(data: {
     bessMaterial: Entities.Material,
     dischargeResult: Entities.DischargeResult,
     dischargeRecords: Entities.DischargeRecord[],
@@ -322,15 +544,15 @@ export class BESSToxicSourceCalculationResponse extends CalculationResponseBase
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.bessMaterial = bessMaterial;
-    this.dischargeResult = dischargeResult;
-    this.dischargeRecords = dischargeRecords;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.bessMaterial = data.bessMaterial;
+    this.dischargeResult = data.dischargeResult;
+    this.dischargeRecords = data.dischargeRecords;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -411,15 +633,7 @@ export class BESSToxicSourceCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: BESSToxicSourceCalculationResponseSchemaData): BESSToxicSourceCalculationResponse {
-    return new BESSToxicSourceCalculationResponse(
-      data.bessMaterial,
-      data.dischargeResult,
-      data.dischargeRecords,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new BESSToxicSourceCalculationResponse(data);
   }
 }
 
@@ -437,19 +651,16 @@ class LongPipeBreachCalculationRequest extends CalculationRequestBase {
   /**
    * LongPipeBreach calculation request class.
    *
-   * @param {Entities.Pipe} pipe -  a pipe entity.
-   * @param {Entities.PipeBreach} pipeBreach -  a pipe breach entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     pipe: Entities.Pipe,
     pipeBreach: Entities.PipeBreach,
     dischargeParameters: Entities.DischargeParameters
-  ) {
+  }) {
     super();
-    this.pipe = pipe;
-    this.pipeBreach = pipeBreach;
-    this.dischargeParameters = dischargeParameters;
+    this.pipe = data.pipe;
+    this.pipeBreach = data.pipeBreach;
+    this.dischargeParameters = data.dischargeParameters;
   }
 }
 
@@ -483,11 +694,7 @@ export class LongPipeBreachCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: LongPipeBreachCalculationRequestSchemaData): LongPipeBreachCalculationRequest {
-    return new LongPipeBreachCalculationRequest(
-      data.pipe,
-      data.pipeBreach,
-      data.dischargeParameters
-    );
+    return new LongPipeBreachCalculationRequest(data);
   }
 }
 
@@ -505,28 +712,26 @@ export class LongPipeBreachCalculation extends CalculationBase {
 state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for 
 flash calculation, etc.
    *
-   * @param {Entities.Pipe} pipe -  a pipe entity.
-   * @param {Entities.PipeBreach} pipeBreach -  a pipe breach entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     pipe: Entities.Pipe,
     pipeBreach: Entities.PipeBreach,
     dischargeParameters: Entities.DischargeParameters
-  ) {
-    super();
-    this.pipe = pipe;
-    this.pipeBreach = pipeBreach;
-    this.dischargeParameters = dischargeParameters;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.pipe = data.pipe;
+    this.pipeBreach = data.pipeBreach;
+    this.dischargeParameters = data.dischargeParameters;
   }
 
   async run() {
     try {
-      const request = new LongPipeBreachCalculationRequest(
-        this.pipe,
-        this.pipeBreach,
-        this.dischargeParameters
-      );
+      const request = new LongPipeBreachCalculationRequest({
+        pipe: this.pipe,
+        pipeBreach: this.pipeBreach,
+        dischargeParameters: this.dischargeParameters
+      });
 
       const schema = new LongPipeBreachCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -596,11 +801,8 @@ export class LongPipeBreachCalculationResponse extends CalculationResponseBase {
   /**
    * LongPipeBreach calculation response class.
    *
-   * @param {Entities.Material} exitMaterial -  a material entity, representing composition of the released material.
-   * @param {Entities.DischargeResult} dischargeResult - Scalar discharge results.
-   * @param {Entities.DischargeRecord[]} dischargeRecords -  an array of discharge records.
    */
-  constructor(
+  constructor(data: {
     exitMaterial: Entities.Material,
     dischargeResult: Entities.DischargeResult,
     dischargeRecords: Entities.DischargeRecord[],
@@ -608,15 +810,15 @@ export class LongPipeBreachCalculationResponse extends CalculationResponseBase {
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.exitMaterial = exitMaterial;
-    this.dischargeResult = dischargeResult;
-    this.dischargeRecords = dischargeRecords;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.exitMaterial = data.exitMaterial;
+    this.dischargeResult = data.dischargeResult;
+    this.dischargeRecords = data.dischargeRecords;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -697,15 +899,7 @@ export class LongPipeBreachCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: LongPipeBreachCalculationResponseSchemaData): LongPipeBreachCalculationResponse {
-    return new LongPipeBreachCalculationResponse(
-      data.exitMaterial,
-      data.dischargeResult,
-      data.dischargeRecords,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new LongPipeBreachCalculationResponse(data);
   }
 }
 
@@ -721,16 +915,14 @@ class VesselCatastrophicRuptureCalculationRequest extends CalculationRequestBase
   /**
    * VesselCatastrophicRupture calculation request class.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     dischargeParameters: Entities.DischargeParameters
-  ) {
+  }) {
     super();
-    this.vessel = vessel;
-    this.dischargeParameters = dischargeParameters;
+    this.vessel = data.vessel;
+    this.dischargeParameters = data.dischargeParameters;
   }
 }
 
@@ -762,10 +954,7 @@ export class VesselCatastrophicRuptureCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: VesselCatastrophicRuptureCalculationRequestSchemaData): VesselCatastrophicRuptureCalculationRequest {
-    return new VesselCatastrophicRuptureCalculationRequest(
-      data.vessel,
-      data.dischargeParameters
-    );
+    return new VesselCatastrophicRuptureCalculationRequest(data);
   }
 }
 
@@ -779,24 +968,23 @@ export class VesselCatastrophicRuptureCalculation extends CalculationBase {
   /**
    * Calculates the instantaneous release from a pressure vessel or storage tank. It includes expansion modelling to atmospheric conditions. The discharge mass, temperature, and other outputs are reported back as discharge records. The height of the release is located at the midpoint of the vessel.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     dischargeParameters: Entities.DischargeParameters
-  ) {
-    super();
-    this.vessel = vessel;
-    this.dischargeParameters = dischargeParameters;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.vessel = data.vessel;
+    this.dischargeParameters = data.dischargeParameters;
   }
 
   async run() {
     try {
-      const request = new VesselCatastrophicRuptureCalculationRequest(
-        this.vessel,
-        this.dischargeParameters
-      );
+      const request = new VesselCatastrophicRuptureCalculationRequest({
+        vessel: this.vessel,
+        dischargeParameters: this.dischargeParameters
+      });
 
       const schema = new VesselCatastrophicRuptureCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -866,11 +1054,8 @@ export class VesselCatastrophicRuptureCalculationResponse extends CalculationRes
   /**
    * VesselCatastrophicRupture calculation response class.
    *
-   * @param {Entities.Material} exitMaterial -  a material entity representing the released material (indentical to storage composition).
-   * @param {Entities.DischargeResult} dischargeResult - Scalar discharge results.
-   * @param {Entities.DischargeRecord[]} dischargeRecords -  an array of discharge records.
    */
-  constructor(
+  constructor(data: {
     exitMaterial: Entities.Material,
     dischargeResult: Entities.DischargeResult,
     dischargeRecords: Entities.DischargeRecord[],
@@ -878,15 +1063,15 @@ export class VesselCatastrophicRuptureCalculationResponse extends CalculationRes
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.exitMaterial = exitMaterial;
-    this.dischargeResult = dischargeResult;
-    this.dischargeRecords = dischargeRecords;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.exitMaterial = data.exitMaterial;
+    this.dischargeResult = data.dischargeResult;
+    this.dischargeRecords = data.dischargeRecords;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -967,15 +1152,7 @@ export class VesselCatastrophicRuptureCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: VesselCatastrophicRuptureCalculationResponseSchemaData): VesselCatastrophicRuptureCalculationResponse {
-    return new VesselCatastrophicRuptureCalculationResponse(
-      data.exitMaterial,
-      data.dischargeResult,
-      data.dischargeRecords,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new VesselCatastrophicRuptureCalculationResponse(data);
   }
 }
 
@@ -993,19 +1170,16 @@ class VesselLeakCalculationRequest extends CalculationRequestBase {
   /**
    * VesselLeak calculation request class.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.Leak} leak -  a leak entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     leak: Entities.Leak,
     dischargeParameters: Entities.DischargeParameters
-  ) {
+  }) {
     super();
-    this.vessel = vessel;
-    this.leak = leak;
-    this.dischargeParameters = dischargeParameters;
+    this.vessel = data.vessel;
+    this.leak = data.leak;
+    this.dischargeParameters = data.dischargeParameters;
   }
 }
 
@@ -1039,11 +1213,7 @@ export class VesselLeakCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: VesselLeakCalculationRequestSchemaData): VesselLeakCalculationRequest {
-    return new VesselLeakCalculationRequest(
-      data.vessel,
-      data.leak,
-      data.dischargeParameters
-    );
+    return new VesselLeakCalculationRequest(data);
   }
 }
 
@@ -1058,28 +1228,26 @@ export class VesselLeakCalculation extends CalculationBase {
   /**
    * Calculates the steady state or time-varying leak from a pressure vessel or storage tank. It includes expansion modelling (from the vessel orifice to atmospheric conditions). The discharge rate, temperature, and other time-dependent outputs at a particular time are reported back as discharge records. For steady-state there are always two DischargeRecords generated; for time-varying the number can vary.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.Leak} leak -  a leak entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     leak: Entities.Leak,
     dischargeParameters: Entities.DischargeParameters
-  ) {
-    super();
-    this.vessel = vessel;
-    this.leak = leak;
-    this.dischargeParameters = dischargeParameters;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.vessel = data.vessel;
+    this.leak = data.leak;
+    this.dischargeParameters = data.dischargeParameters;
   }
 
   async run() {
     try {
-      const request = new VesselLeakCalculationRequest(
-        this.vessel,
-        this.leak,
-        this.dischargeParameters
-      );
+      const request = new VesselLeakCalculationRequest({
+        vessel: this.vessel,
+        leak: this.leak,
+        dischargeParameters: this.dischargeParameters
+      });
 
       const schema = new VesselLeakCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -1149,11 +1317,8 @@ export class VesselLeakCalculationResponse extends CalculationResponseBase {
   /**
    * VesselLeak calculation response class.
    *
-   * @param {Entities.Material} exitMaterial -  a material entity representing the released material (may differ from storage composition).
-   * @param {Entities.DischargeResult} dischargeResult - Scalar discharge results.
-   * @param {Entities.DischargeRecord[]} dischargeRecords -  an array of discharge records.
    */
-  constructor(
+  constructor(data: {
     exitMaterial: Entities.Material,
     dischargeResult: Entities.DischargeResult,
     dischargeRecords: Entities.DischargeRecord[],
@@ -1161,15 +1326,15 @@ export class VesselLeakCalculationResponse extends CalculationResponseBase {
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.exitMaterial = exitMaterial;
-    this.dischargeResult = dischargeResult;
-    this.dischargeRecords = dischargeRecords;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.exitMaterial = data.exitMaterial;
+    this.dischargeResult = data.dischargeResult;
+    this.dischargeRecords = data.dischargeRecords;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -1250,15 +1415,7 @@ export class VesselLeakCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: VesselLeakCalculationResponseSchemaData): VesselLeakCalculationResponse {
-    return new VesselLeakCalculationResponse(
-      data.exitMaterial,
-      data.dischargeResult,
-      data.dischargeRecords,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new VesselLeakCalculationResponse(data);
   }
 }
 
@@ -1276,19 +1433,16 @@ class VesselLineRuptureCalculationRequest extends CalculationRequestBase {
   /**
    * VesselLineRupture calculation request class.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.LineRupture} lineRupture -  a line rupture entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     lineRupture: Entities.LineRupture,
     dischargeParameters: Entities.DischargeParameters
-  ) {
+  }) {
     super();
-    this.vessel = vessel;
-    this.lineRupture = lineRupture;
-    this.dischargeParameters = dischargeParameters;
+    this.vessel = data.vessel;
+    this.lineRupture = data.lineRupture;
+    this.dischargeParameters = data.dischargeParameters;
   }
 }
 
@@ -1322,11 +1476,7 @@ export class VesselLineRuptureCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: VesselLineRuptureCalculationRequestSchemaData): VesselLineRuptureCalculationRequest {
-    return new VesselLineRuptureCalculationRequest(
-      data.vessel,
-      data.lineRupture,
-      data.dischargeParameters
-    );
+    return new VesselLineRuptureCalculationRequest(data);
   }
 }
 
@@ -1341,28 +1491,26 @@ export class VesselLineRuptureCalculation extends CalculationBase {
   /**
    * Calculations of discharge from a short pipe attached to a vessel.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.LineRupture} lineRupture -  a line rupture entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     lineRupture: Entities.LineRupture,
     dischargeParameters: Entities.DischargeParameters
-  ) {
-    super();
-    this.vessel = vessel;
-    this.lineRupture = lineRupture;
-    this.dischargeParameters = dischargeParameters;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.vessel = data.vessel;
+    this.lineRupture = data.lineRupture;
+    this.dischargeParameters = data.dischargeParameters;
   }
 
   async run() {
     try {
-      const request = new VesselLineRuptureCalculationRequest(
-        this.vessel,
-        this.lineRupture,
-        this.dischargeParameters
-      );
+      const request = new VesselLineRuptureCalculationRequest({
+        vessel: this.vessel,
+        lineRupture: this.lineRupture,
+        dischargeParameters: this.dischargeParameters
+      });
 
       const schema = new VesselLineRuptureCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -1432,11 +1580,8 @@ export class VesselLineRuptureCalculationResponse extends CalculationResponseBas
   /**
    * VesselLineRupture calculation response class.
    *
-   * @param {Entities.Material} exitMaterial -  a material entity representing the released material (which may differ from storage composition).
-   * @param {Entities.DischargeResult} dischargeResult - Scalar discharge results.
-   * @param {Entities.DischargeRecord[]} dischargeRecords -  an array of discharge records.
    */
-  constructor(
+  constructor(data: {
     exitMaterial: Entities.Material,
     dischargeResult: Entities.DischargeResult,
     dischargeRecords: Entities.DischargeRecord[],
@@ -1444,15 +1589,15 @@ export class VesselLineRuptureCalculationResponse extends CalculationResponseBas
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.exitMaterial = exitMaterial;
-    this.dischargeResult = dischargeResult;
-    this.dischargeRecords = dischargeRecords;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.exitMaterial = data.exitMaterial;
+    this.dischargeResult = data.dischargeResult;
+    this.dischargeRecords = data.dischargeRecords;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -1533,15 +1678,7 @@ export class VesselLineRuptureCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: VesselLineRuptureCalculationResponseSchemaData): VesselLineRuptureCalculationResponse {
-    return new VesselLineRuptureCalculationResponse(
-      data.exitMaterial,
-      data.dischargeResult,
-      data.dischargeRecords,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new VesselLineRuptureCalculationResponse(data);
   }
 }
 
@@ -1559,19 +1696,16 @@ class VesselReliefValveCalculationRequest extends CalculationRequestBase {
   /**
    * VesselReliefValve calculation request class.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.ReliefValve} reliefValve -  a relief valve entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     reliefValve: Entities.ReliefValve,
     dischargeParameters: Entities.DischargeParameters
-  ) {
+  }) {
     super();
-    this.vessel = vessel;
-    this.reliefValve = reliefValve;
-    this.dischargeParameters = dischargeParameters;
+    this.vessel = data.vessel;
+    this.reliefValve = data.reliefValve;
+    this.dischargeParameters = data.dischargeParameters;
   }
 }
 
@@ -1605,11 +1739,7 @@ export class VesselReliefValveCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: VesselReliefValveCalculationRequestSchemaData): VesselReliefValveCalculationRequest {
-    return new VesselReliefValveCalculationRequest(
-      data.vessel,
-      data.reliefValve,
-      data.dischargeParameters
-    );
+    return new VesselReliefValveCalculationRequest(data);
   }
 }
 
@@ -1624,28 +1754,26 @@ export class VesselReliefValveCalculation extends CalculationBase {
   /**
    * Calculations of venting from a relief valve attached to a vessel.
    *
-   * @param {Entities.Vessel} vessel -  a vessel entity.
-   * @param {Entities.ReliefValve} reliefValve -  a relief valve entity.
-   * @param {Entities.DischargeParameters} dischargeParameters -  a discharge parameters entity.
    */
-  constructor(
+  constructor(data: {
     vessel: Entities.Vessel,
     reliefValve: Entities.ReliefValve,
     dischargeParameters: Entities.DischargeParameters
-  ) {
-    super();
-    this.vessel = vessel;
-    this.reliefValve = reliefValve;
-    this.dischargeParameters = dischargeParameters;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.vessel = data.vessel;
+    this.reliefValve = data.reliefValve;
+    this.dischargeParameters = data.dischargeParameters;
   }
 
   async run() {
     try {
-      const request = new VesselReliefValveCalculationRequest(
-        this.vessel,
-        this.reliefValve,
-        this.dischargeParameters
-      );
+      const request = new VesselReliefValveCalculationRequest({
+        vessel: this.vessel,
+        reliefValve: this.reliefValve,
+        dischargeParameters: this.dischargeParameters
+      });
 
       const schema = new VesselReliefValveCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -1715,11 +1843,8 @@ export class VesselReliefValveCalculationResponse extends CalculationResponseBas
   /**
    * VesselReliefValve calculation response class.
    *
-   * @param {Entities.Material} exitMaterial -  a material entity representing the released material (which may differ from storage composition).
-   * @param {Entities.DischargeResult} dischargeResult - Scalar discharge results.
-   * @param {Entities.DischargeRecord[]} dischargeRecords -  an array of discharge records.
    */
-  constructor(
+  constructor(data: {
     exitMaterial: Entities.Material,
     dischargeResult: Entities.DischargeResult,
     dischargeRecords: Entities.DischargeRecord[],
@@ -1727,15 +1852,15 @@ export class VesselReliefValveCalculationResponse extends CalculationResponseBas
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.exitMaterial = exitMaterial;
-    this.dischargeResult = dischargeResult;
-    this.dischargeRecords = dischargeRecords;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.exitMaterial = data.exitMaterial;
+    this.dischargeResult = data.dischargeResult;
+    this.dischargeRecords = data.dischargeRecords;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -1816,15 +1941,7 @@ export class VesselReliefValveCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: VesselReliefValveCalculationResponseSchemaData): VesselReliefValveCalculationResponse {
-    return new VesselReliefValveCalculationResponse(
-      data.exitMaterial,
-      data.dischargeResult,
-      data.dischargeRecords,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new VesselReliefValveCalculationResponse(data);
   }
 }
 
@@ -1840,16 +1957,14 @@ class VesselStateCalculationRequest extends CalculationRequestBase {
   /**
    * VesselState calculation request class.
    *
-   * @param {Entities.Material} material -  a material entity.
-   * @param {Entities.State} materialState -  a state entity describing the fluid pressure, temperature, liquid fraction.
    */
-  constructor(
+  constructor(data: {
     material: Entities.Material,
     materialState: Entities.State
-  ) {
+  }) {
     super();
-    this.material = material;
-    this.materialState = materialState;
+    this.material = data.material;
+    this.materialState = data.materialState;
   }
 }
 
@@ -1881,10 +1996,7 @@ export class VesselStateCalculationRequestSchema {
   }
 
   makeCalculationRequest(data: VesselStateCalculationRequestSchemaData): VesselStateCalculationRequest {
-    return new VesselStateCalculationRequest(
-      data.material,
-      data.materialState
-    );
+    return new VesselStateCalculationRequest(data);
   }
 }
 
@@ -1899,24 +2011,23 @@ export class VesselStateCalculation extends CalculationBase {
 the vessel conditions (e.g. Pure gas, Stratified Two-Phase vessel, Pressurised Liquid) that can be input to the 
 source term models: vessel leak and vessel catastrophic rupture.
    *
-   * @param {Entities.Material} material -  a material entity.
-   * @param {Entities.State} materialState -  a state entity describing the fluid pressure, temperature, liquid fraction.
    */
-  constructor(
+  constructor(data: {
     material: Entities.Material,
     materialState: Entities.State
-  ) {
-    super();
-    this.material = material;
-    this.materialState = materialState;
+    controller?: AbortController;
+  }) {
+    super(data.controller);
+    this.material = data.material;
+    this.materialState = data.materialState;
   }
 
   async run() {
     try {
-      const request = new VesselStateCalculationRequest(
-        this.material,
-        this.materialState
-      );
+      const request = new VesselStateCalculationRequest({
+        material: this.material,
+        materialState: this.materialState
+      });
 
       const schema = new VesselStateCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
@@ -1978,24 +2089,22 @@ export class VesselStateCalculationResponse extends CalculationResponseBase {
   /**
    * VesselState calculation response class.
    *
-   * @param {Enums.VesselConditions} vesselConditions - The conditions of the material in the vessel.
-   * @param {Entities.State} outputState -  a state entity describing the fluid pressure, temperature and liquid fraction after the flash calculation.
    */
-  constructor(
+  constructor(data: {
     vesselConditions: Enums.VesselConditions,
     outputState: Entities.State,
     resultCode: Enums.ResultCode,
     messages: string[],
     calculationElapsedTime: number,
     operationId: string
-  ) {
+  }) {
     super();
-    this.vesselConditions = vesselConditions;
-    this.outputState = outputState;
-    this.resultCode = resultCode;
-    this.messages = messages;
-    this.calculationElapsedTime = calculationElapsedTime;
-    this.operationId = operationId;
+    this.vesselConditions = data.vesselConditions;
+    this.outputState = data.outputState;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
@@ -2063,13 +2172,6 @@ export class VesselStateCalculationResponseSchema {
   }
 
   makeCalculationResponse(data: VesselStateCalculationResponseSchemaData): VesselStateCalculationResponse {
-    return new VesselStateCalculationResponse(
-      data.vesselConditions,
-      data.outputState,
-      data.resultCode,
-      data.messages,
-      data.calculationElapsedTime,
-      data.operationId
-    );
+    return new VesselStateCalculationResponse(data);
   }
 }