@dnv-plant/typescriptpws 1.0.97 → 1.0.98

package/src/calculations/discharge.ts

@@ -1,15 +1,19 @@
-/***********************************************************************
- * This file has been auto-generated by a code generation tool.
- *
- * DO NOT MODIFY THIS FILE
- * This file is maintained by DNV.
- * 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.97
- * Date/time: 13 Apr 2026 17:02:52
- * Template:  templates/typescriptpws/calculations.razor.
- ***********************************************************************/
+// ************************************************************************************
+// *
+// *  This file has been auto-generated by a code generation tool.
+// *
+// *  DO NOT MODIFY THIS FILE
+// *  This file is maintained by DNV.
+// *  Editing it may lead to inconsistent results and limit DNV's ability to provide support.
+// *  Please contact DNV if you believe changes are required.
+// *
+// *  API version:      1.0.
+// *  MDE version:      9.3.8211.
+// *  Package version:  1.0.98
+// *  Date/time:        23 Jun 2026 12:11:11.
+// *  Template:         TYPE_SCRIPT_PWS/calculations.sbn.
+// *
+// ************************************************************************************
 
 import * as Enums from '../enums';
 import * as Entities from '../entities';
@@ -78,7 +82,7 @@ export class BESSConfidenceIntervalEnergyScalingCalculation extends CalculationB
   kLower?: number;
 
   /**
-   *  Confidence interval scaling values for a BESS calculation.
+   * Calculates scaling values for the energy which correspond to the specified confidence interval for the toxic mass. The battery chemistry gives us a specific data set for which the best-fit of toxic mass / unit energy is calculated. There will be some degree of scatter around this fit and a user-specified confidence interval can be calculated giving the range of toxic masses for a known energy. This interval can also be represented by scaling values for the energy. This will give upper and lower energy values which for this chemistry will give toxic masses corresponding to the confidence interval.
    *
    */
   constructor(data: { chemistry: number; confidenceInterval: number; controller?: AbortController }) {
@@ -233,46 +237,237 @@ export class BESSConfidenceIntervalEnergyScalingCalculationResponseSchema {
   }
 }
 
-export interface BESSToxicSourceCalculationRequestSchemaData {
+export interface BESSDefaultOffgasMaterialCalculationRequestSchemaData {
+  bessChemistry: Enums.BESSChemistry;
+}
+
+class BESSDefaultOffgasMaterialCalculationRequest extends CalculationRequestBase {
+  bessChemistry: Enums.BESSChemistry;
+
+  /**
+   * BESSDefaultOffgasMaterial calculation request class.
+   *
+   */
+  constructor(data: { bessChemistry: Enums.BESSChemistry }) {
+    super();
+    this.bessChemistry = data.bessChemistry;
+  }
+}
+
+export class BESSDefaultOffgasMaterialCalculationRequestSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the BESSDefaultOffgasMaterial calculation request.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      bessChemistry: Joi.string().valid(...Object.values(Enums.BESSChemistry)),
+    }).unknown(true);
+
+    this.propertyTypes = {
+      bessChemistry: 'Enums.BESSChemistry',
+    };
+  }
+
+  validate(data: BESSDefaultOffgasMaterialCalculationRequestSchemaData): BESSDefaultOffgasMaterialCalculationRequest {
+    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: BESSDefaultOffgasMaterialCalculationRequestSchemaData): BESSDefaultOffgasMaterialCalculationRequest {
+    return new BESSDefaultOffgasMaterialCalculationRequest(data);
+  }
+}
+
+export class BESSDefaultOffgasMaterialCalculation extends CalculationBase {
+  bessChemistry: Enums.BESSChemistry;
+  defaultMaterial?: Entities.Material;
+
+  /**
+   * Returns the default material for the BESS unit based on battery chemistry. Where the user does not have a specific composition, we can provide a suitable material as default based on battery chemistry.
+   *
+   */
+  constructor(data: { bessChemistry: Enums.BESSChemistry; controller?: AbortController }) {
+    super(data.controller);
+    this.bessChemistry = data.bessChemistry;
+  }
+
+  async run() {
+    try {
+      const request = new BESSDefaultOffgasMaterialCalculationRequest({
+        bessChemistry: this.bessChemistry,
+      });
+
+      const schema = new BESSDefaultOffgasMaterialCalculationRequestSchema();
+      const validatedRequest = schema.validate(request);
+
+      const requestJson = JSON.stringify(validatedRequest);
+      const url = `${getAnalyticsApiTarget()}calculatebessdefaultoffgasmaterial?clientId=${getClientAliasId()}`;
+
+      this.resultCode = Enums.ResultCode.UNEXPECTED_APPLICATION_ERROR;
+
+      const { data } = await this.postRequest(url, requestJson);
+
+      const responseSchema = new BESSDefaultOffgasMaterialCalculationResponseSchema();
+      const validatedResponse = responseSchema.validate(data);
+
+      this.resultCode = validatedResponse.resultCode;
+      if (this.resultCode === Enums.ResultCode.SUCCESS) {
+        Object.assign(this, {
+          defaultMaterial: validatedResponse.defaultMaterial,
+          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 = ['* BESSDefaultOffgasMaterial'];
+
+    parts.push(`defaultMaterial: ${String(this.defaultMaterial)}`);
+    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 BESSDefaultOffgasMaterialCalculationResponse extends CalculationResponseBase {
+  defaultMaterial: Entities.Material;
+
+  /**
+   * BESSDefaultOffgasMaterial calculation response class.
+   *
+   */
+  constructor(data: { defaultMaterial: Entities.Material; resultCode: Enums.ResultCode; messages: string[]; calculationElapsedTime: number; operationId: string }) {
+    super();
+    this.defaultMaterial = data.defaultMaterial;
+    this.resultCode = data.resultCode;
+    this.messages = data.messages;
+    this.calculationElapsedTime = data.calculationElapsedTime;
+    this.operationId = data.operationId;
+  }
+
+  initialiseFromDictionary(data: { [key: string]: unknown }) {
+    if (data.defaultMaterial) {
+      this.defaultMaterial = new Entities.Material();
+      this.defaultMaterial.initialiseFromDictionary(data.defaultMaterial as { [key: string]: unknown });
+    }
+    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 BESSDefaultOffgasMaterialCalculationResponseSchemaData {
+  defaultMaterial: Entities.Material;
+  resultCode: Enums.ResultCode;
+  messages: string[];
+  calculationElapsedTime: number;
+  operationId: string;
+}
+
+export class BESSDefaultOffgasMaterialCalculationResponseSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the BESSDefaultOffgasMaterial calculation response.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      defaultMaterial: new EntitySchemas.MaterialSchema().schema,
+      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 = {
+      defaultMaterial: 'Entities.Material',
+    };
+  }
+
+  validate(data: BESSDefaultOffgasMaterialCalculationResponseSchemaData): BESSDefaultOffgasMaterialCalculationResponse {
+    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: BESSDefaultOffgasMaterialCalculationResponseSchemaData): BESSDefaultOffgasMaterialCalculationResponse {
+    return new BESSDefaultOffgasMaterialCalculationResponse(data);
+  }
+}
+
+export interface BESSDefaultSmokeMaterialCalculationRequestSchemaData {
   bessUnit: Entities.BESSUnit;
-  bessRelease: Entities.BESSRelease;
 }
 
-class BESSToxicSourceCalculationRequest extends CalculationRequestBase {
+class BESSDefaultSmokeMaterialCalculationRequest extends CalculationRequestBase {
   bessUnit: Entities.BESSUnit;
-  bessRelease: Entities.BESSRelease;
 
   /**
-   * BESSToxicSource calculation request class.
+   * BESSDefaultSmokeMaterial calculation request class.
    *
    */
-  constructor(data: { bessUnit: Entities.BESSUnit; bessRelease: Entities.BESSRelease }) {
+  constructor(data: { bessUnit: Entities.BESSUnit }) {
     super();
     this.bessUnit = data.bessUnit;
-    this.bessRelease = data.bessRelease;
   }
 }
 
-export class BESSToxicSourceCalculationRequestSchema {
+export class BESSDefaultSmokeMaterialCalculationRequestSchema {
   schema: Joi.ObjectSchema;
   propertyTypes: Record<string, string>;
 
   /**
-   * Schema for the BESSToxicSource calculation request.
+   * Schema for the BESSDefaultSmokeMaterial calculation request.
    */
   constructor() {
     this.schema = Joi.object({
       bessUnit: new EntitySchemas.BESSUnitSchema().schema,
-      bessRelease: new EntitySchemas.BESSReleaseSchema().schema,
     }).unknown(true);
 
     this.propertyTypes = {
       bessUnit: 'Entities.BESSUnit',
-      bessRelease: 'Entities.BESSRelease',
     };
   }
 
-  validate(data: BESSToxicSourceCalculationRequestSchemaData): BESSToxicSourceCalculationRequest {
+  validate(data: BESSDefaultSmokeMaterialCalculationRequestSchemaData): BESSDefaultSmokeMaterialCalculationRequest {
     const { error, value } = this.schema.validate(data, { abortEarly: false });
     if (error) {
       throw new Error(`Validation error: ${error.details.map((x) => x.message).join(', ')}`);
@@ -280,54 +475,47 @@ export class BESSToxicSourceCalculationRequestSchema {
     return this.makeCalculationRequest(value);
   }
 
-  makeCalculationRequest(data: BESSToxicSourceCalculationRequestSchemaData): BESSToxicSourceCalculationRequest {
-    return new BESSToxicSourceCalculationRequest(data);
+  makeCalculationRequest(data: BESSDefaultSmokeMaterialCalculationRequestSchemaData): BESSDefaultSmokeMaterialCalculationRequest {
+    return new BESSDefaultSmokeMaterialCalculationRequest(data);
   }
 }
 
-export class BESSToxicSourceCalculation extends CalculationBase {
+export class BESSDefaultSmokeMaterialCalculation extends CalculationBase {
   bessUnit: Entities.BESSUnit;
-  bessRelease: Entities.BESSRelease;
-  bessMaterial?: Entities.Material;
-  dischargeResult?: Entities.DischargeResult;
-  dischargeRecords?: Entities.DischargeRecord[];
+  material?: Entities.Material;
 
   /**
-   *  Toxic outflow from a BESS unit.
+   * Returns the default smoke material for the BESS unit based on battery chemistry and energy capacity. HF content is defined from an internal calculation and combined with estimated combustion products to define the material.
    *
    */
-  constructor(data: { bessUnit: Entities.BESSUnit; bessRelease: Entities.BESSRelease; controller?: AbortController }) {
+  constructor(data: { bessUnit: Entities.BESSUnit; controller?: AbortController }) {
     super(data.controller);
     this.bessUnit = data.bessUnit;
-    this.bessRelease = data.bessRelease;
   }
 
   async run() {
     try {
-      const request = new BESSToxicSourceCalculationRequest({
+      const request = new BESSDefaultSmokeMaterialCalculationRequest({
         bessUnit: this.bessUnit,
-        bessRelease: this.bessRelease,
       });
 
-      const schema = new BESSToxicSourceCalculationRequestSchema();
+      const schema = new BESSDefaultSmokeMaterialCalculationRequestSchema();
       const validatedRequest = schema.validate(request);
 
       const requestJson = JSON.stringify(validatedRequest);
-      const url = `${getAnalyticsApiTarget()}calculatebesstoxicsource?clientId=${getClientAliasId()}`;
+      const url = `${getAnalyticsApiTarget()}calculatebessdefaultsmokematerial?clientId=${getClientAliasId()}`;
 
       this.resultCode = Enums.ResultCode.UNEXPECTED_APPLICATION_ERROR;
 
       const { data } = await this.postRequest(url, requestJson);
 
-      const responseSchema = new BESSToxicSourceCalculationResponseSchema();
+      const responseSchema = new BESSDefaultSmokeMaterialCalculationResponseSchema();
       const validatedResponse = responseSchema.validate(data);
 
       this.resultCode = validatedResponse.resultCode;
       if (this.resultCode === Enums.ResultCode.SUCCESS) {
         Object.assign(this, {
-          bessMaterial: validatedResponse.bessMaterial,
-          dischargeResult: validatedResponse.dischargeResult,
-          dischargeRecords: validatedResponse.dischargeRecords,
+          material: validatedResponse.material,
           resultCode: validatedResponse.resultCode,
           messages: validatedResponse.messages ?? [],
           calculationElapsedTime: validatedResponse.calculationElapsedTime,
@@ -349,16 +537,9 @@ export class BESSToxicSourceCalculation extends CalculationBase {
   }
 
   toString() {
-    const parts = ['* BESSToxicSource'];
+    const parts = ['* BESSDefaultSmokeMaterial'];
 
-    parts.push(`bessMaterial: ${String(this.bessMaterial)}`);
-    parts.push(`dischargeResult: ${String(this.dischargeResult)}`);
-    parts.push('*** dischargeRecords:');
-    parts.push(
-      this.dischargeRecords && this.dischargeRecords.length > 0
-        ? this.dischargeRecords.map((point) => `dischargeRecordsElement: ${point}`).join('\n')
-        : 'dischargeRecords does not contain any elements',
-    );
+    parts.push(`material: ${String(this.material)}`);
     parts.push(`resultCode: ${String(this.resultCode)}`);
     parts.push('*** messages:');
     parts.push(`messages: ${this.messages !== undefined ? this.messages : '(None)'}`);
@@ -369,28 +550,16 @@ export class BESSToxicSourceCalculation extends CalculationBase {
   }
 }
 
-export class BESSToxicSourceCalculationResponse extends CalculationResponseBase {
-  bessMaterial: Entities.Material;
-  dischargeResult: Entities.DischargeResult;
-  dischargeRecords: Entities.DischargeRecord[];
+export class BESSDefaultSmokeMaterialCalculationResponse extends CalculationResponseBase {
+  material: Entities.Material;
 
   /**
-   * BESSToxicSource calculation response class.
+   * BESSDefaultSmokeMaterial calculation response class.
    *
    */
-  constructor(data: {
-    bessMaterial: Entities.Material;
-    dischargeResult: Entities.DischargeResult;
-    dischargeRecords: Entities.DischargeRecord[];
-    resultCode: Enums.ResultCode;
-    messages: string[];
-    calculationElapsedTime: number;
-    operationId: string;
-  }) {
+  constructor(data: { material: Entities.Material; resultCode: Enums.ResultCode; messages: string[]; calculationElapsedTime: number; operationId: string }) {
     super();
-    this.bessMaterial = data.bessMaterial;
-    this.dischargeResult = data.dischargeResult;
-    this.dischargeRecords = data.dischargeRecords;
+    this.material = data.material;
     this.resultCode = data.resultCode;
     this.messages = data.messages;
     this.calculationElapsedTime = data.calculationElapsedTime;
@@ -398,20 +567,9 @@ export class BESSToxicSourceCalculationResponse extends CalculationResponseBase
   }
 
   initialiseFromDictionary(data: { [key: string]: unknown }) {
-    if (data.bessMaterial) {
-      this.bessMaterial = new Entities.Material();
-      this.bessMaterial.initialiseFromDictionary(data.bessMaterial as { [key: string]: unknown });
-    }
-    if (data.dischargeResult) {
-      this.dischargeResult = new Entities.DischargeResult();
-      this.dischargeResult.initialiseFromDictionary(data.dischargeResult as { [key: string]: unknown });
-    }
-    if (data.dischargeRecords && Array.isArray(data.dischargeRecords)) {
-      this.dischargeRecords = data.dischargeRecords.map((item) => {
-        const record = new Entities.DischargeRecord();
-        record.initialiseFromDictionary(item);
-        return record;
-      });
+    if (data.material) {
+      this.material = new Entities.Material();
+      this.material.initialiseFromDictionary(data.material as { [key: string]: unknown });
     }
     if (data.resultCode !== undefined && (typeof data.resultCode === 'string' || typeof data.resultCode === 'number')) {
       this.resultCode = data.resultCode as Enums.ResultCode;
@@ -429,28 +587,24 @@ export class BESSToxicSourceCalculationResponse extends CalculationResponseBase
   }
 }
 
-export interface BESSToxicSourceCalculationResponseSchemaData {
-  bessMaterial: Entities.Material;
-  dischargeResult: Entities.DischargeResult;
-  dischargeRecords: Entities.DischargeRecord[];
+export interface BESSDefaultSmokeMaterialCalculationResponseSchemaData {
+  material: Entities.Material;
   resultCode: Enums.ResultCode;
   messages: string[];
   calculationElapsedTime: number;
   operationId: string;
 }
 
-export class BESSToxicSourceCalculationResponseSchema {
+export class BESSDefaultSmokeMaterialCalculationResponseSchema {
   schema: Joi.ObjectSchema;
   propertyTypes: Record<string, string>;
 
   /**
-   * Schema for the BESSToxicSource calculation response.
+   * Schema for the BESSDefaultSmokeMaterial calculation response.
    */
   constructor() {
     this.schema = Joi.object({
-      bessMaterial: new EntitySchemas.MaterialSchema().schema,
-      dischargeResult: new EntitySchemas.DischargeResultSchema().schema,
-      dischargeRecords: Joi.array().items(new EntitySchemas.DischargeRecordSchema().schema).allow(null),
+      material: new EntitySchemas.MaterialSchema().schema,
       resultCode: Joi.string().valid(...Object.values(Enums.ResultCode)),
       messages: Joi.array().items(Joi.string()),
       calculationElapsedTime: Joi.number().unsafe(),
@@ -458,13 +612,11 @@ export class BESSToxicSourceCalculationResponseSchema {
     }).unknown(true);
 
     this.propertyTypes = {
-      bessMaterial: 'Entities.Material',
-      dischargeResult: 'Entities.DischargeResult',
-      dischargeRecords: 'Entities.DischargeRecord[]',
+      material: 'Entities.Material',
     };
   }
 
-  validate(data: BESSToxicSourceCalculationResponseSchemaData): BESSToxicSourceCalculationResponse {
+  validate(data: BESSDefaultSmokeMaterialCalculationResponseSchemaData): BESSDefaultSmokeMaterialCalculationResponse {
     const { error, value } = this.schema.validate(data, { abortEarly: false });
     if (error) {
       throw new Error(`Validation error: ${error.details.map((x) => x.message).join(', ')}`);
@@ -472,8 +624,8 @@ export class BESSToxicSourceCalculationResponseSchema {
     return this.makeCalculationResponse(value);
   }
 
-  makeCalculationResponse(data: BESSToxicSourceCalculationResponseSchemaData): BESSToxicSourceCalculationResponse {
-    return new BESSToxicSourceCalculationResponse(data);
+  makeCalculationResponse(data: BESSDefaultSmokeMaterialCalculationResponseSchemaData): BESSDefaultSmokeMaterialCalculationResponse {
+    return new BESSDefaultSmokeMaterialCalculationResponse(data);
   }
 }
 
@@ -543,10 +695,7 @@ export class LongPipeBreachCalculation extends CalculationBase {
   dischargeRecords?: Entities.DischargeRecord[];
 
   /**
-   * Calculates the time-varying release from a breach (full bore or partial) in a long pipeline. Currently restricted to gas pipelines only. The release combines the outflow from the branches upstream and downstream of the breach. Valves can be specified along the pipe length. The release stops once the pipe has depressurised. The discharge mass, temperature, and other outputs are reported back as discharge records.  
-\remark Pressure as part of the state defined in pipe entity is in absolute units, this is to align with other uses of the 
-state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for 
-flash calculation, etc.
+   * Calculates the time-varying release from a breach (full bore or partial) in a long pipeline. Currently restricted to gas pipelines only. The release combines the outflow from the branches upstream and downstream of the breach. Valves can be specified along the pipe length. The release stops once the pipe has depressurised. The discharge mass, temperature, and other outputs are reported back as discharge records. * Note: Pressure as part of the state defined in pipe entity is in absolute units, which is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
    *
    */
   constructor(data: { pipe: Entities.Pipe; pipeBreach: Entities.PipeBreach; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
@@ -792,7 +941,7 @@ export class VesselCatastrophicRuptureCalculation extends CalculationBase {
   dischargeRecords?: Entities.DischargeRecord[];
 
   /**
-   * 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.
+   * 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 * Note: Pressure as part of the state defined in vessel entity is in absolute units, this is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
    *
    */
   constructor(data: { vessel: Entities.Vessel; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
@@ -1042,7 +1191,7 @@ export class VesselLeakCalculation extends CalculationBase {
   dischargeRecords?: Entities.DischargeRecord[];
 
   /**
-   * 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.
+   * 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. * Note: Pressure as part of the state defined in vessel entity is in absolute units, this is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
    *
    */
   constructor(data: { vessel: Entities.Vessel; leak: Entities.Leak; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
@@ -1294,7 +1443,7 @@ export class VesselLineRuptureCalculation extends CalculationBase {
   dischargeRecords?: Entities.DischargeRecord[];
 
   /**
-   * Calculations of discharge from a short pipe attached to a vessel.
+   * Calculates the steady state or time-varying rupture of a short pipe attached to a pressure vessel or storage tank. It includes expansion modelling (pressure drop along the pipe and 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. * Note: Pressure as part of the state defined in vessel entity is in absolute units, this is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
    *
    */
   constructor(data: { vessel: Entities.Vessel; lineRupture: Entities.LineRupture; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
@@ -1546,7 +1695,7 @@ export class VesselReliefValveCalculation extends CalculationBase {
   dischargeRecords?: Entities.DischargeRecord[];
 
   /**
-   * Calculations of venting from a relief valve attached to a vessel.
+   * Calculates the steady state or time-varying rupture of a relief valve attached to a pressure vessel or storage tank. It includes expansion modelling (pressure drop along the pipe and 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. * Note: Pressure as part of the state defined in vessel entity is in absolute units, this is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
    *
    */
   constructor(data: { vessel: Entities.Vessel; reliefValve: Entities.ReliefValve; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
@@ -1732,6 +1881,502 @@ export class VesselReliefValveCalculationResponseSchema {
   }
 }
 
+export interface VesselSphereCatastrophicRuptureCalculationRequestSchemaData {
+  vesselSphere: Entities.VesselSphere;
+  dischargeParameters: Entities.DischargeParameters;
+}
+
+class VesselSphereCatastrophicRuptureCalculationRequest extends CalculationRequestBase {
+  vesselSphere: Entities.VesselSphere;
+  dischargeParameters: Entities.DischargeParameters;
+
+  /**
+   * VesselSphereCatastrophicRupture calculation request class.
+   *
+   */
+  constructor(data: { vesselSphere: Entities.VesselSphere; dischargeParameters: Entities.DischargeParameters }) {
+    super();
+    this.vesselSphere = data.vesselSphere;
+    this.dischargeParameters = data.dischargeParameters;
+  }
+}
+
+export class VesselSphereCatastrophicRuptureCalculationRequestSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the VesselSphereCatastrophicRupture calculation request.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      vesselSphere: new EntitySchemas.VesselSphereSchema().schema,
+      dischargeParameters: new EntitySchemas.DischargeParametersSchema().schema,
+    }).unknown(true);
+
+    this.propertyTypes = {
+      vesselSphere: 'Entities.VesselSphere',
+      dischargeParameters: 'Entities.DischargeParameters',
+    };
+  }
+
+  validate(data: VesselSphereCatastrophicRuptureCalculationRequestSchemaData): VesselSphereCatastrophicRuptureCalculationRequest {
+    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: VesselSphereCatastrophicRuptureCalculationRequestSchemaData): VesselSphereCatastrophicRuptureCalculationRequest {
+    return new VesselSphereCatastrophicRuptureCalculationRequest(data);
+  }
+}
+
+export class VesselSphereCatastrophicRuptureCalculation extends CalculationBase {
+  vesselSphere: Entities.VesselSphere;
+  dischargeParameters: Entities.DischargeParameters;
+  exitMaterial?: Entities.Material;
+  dischargeResult?: Entities.DischargeResult;
+  dischargeRecords?: Entities.DischargeRecord[];
+
+  /**
+   * Calculates the instantaneous release from a spherical vessel. 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 * Note: Pressure as part of the state defined in vessel entity is in absolute units, this is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
+   *
+   */
+  constructor(data: { vesselSphere: Entities.VesselSphere; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
+    super(data.controller);
+    this.vesselSphere = data.vesselSphere;
+    this.dischargeParameters = data.dischargeParameters;
+  }
+
+  async run() {
+    try {
+      const request = new VesselSphereCatastrophicRuptureCalculationRequest({
+        vesselSphere: this.vesselSphere,
+        dischargeParameters: this.dischargeParameters,
+      });
+
+      const schema = new VesselSphereCatastrophicRuptureCalculationRequestSchema();
+      const validatedRequest = schema.validate(request);
+
+      const requestJson = JSON.stringify(validatedRequest);
+      const url = `${getAnalyticsApiTarget()}calculatevesselspherecatastrophicrupture?clientId=${getClientAliasId()}`;
+
+      this.resultCode = Enums.ResultCode.UNEXPECTED_APPLICATION_ERROR;
+
+      const { data } = await this.postRequest(url, requestJson);
+
+      const responseSchema = new VesselSphereCatastrophicRuptureCalculationResponseSchema();
+      const validatedResponse = responseSchema.validate(data);
+
+      this.resultCode = validatedResponse.resultCode;
+      if (this.resultCode === Enums.ResultCode.SUCCESS) {
+        Object.assign(this, {
+          exitMaterial: validatedResponse.exitMaterial,
+          dischargeResult: validatedResponse.dischargeResult,
+          dischargeRecords: validatedResponse.dischargeRecords,
+          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 = ['* VesselSphereCatastrophicRupture'];
+
+    parts.push(`exitMaterial: ${String(this.exitMaterial)}`);
+    parts.push(`dischargeResult: ${String(this.dischargeResult)}`);
+    parts.push('*** dischargeRecords:');
+    parts.push(
+      this.dischargeRecords && this.dischargeRecords.length > 0
+        ? this.dischargeRecords.map((point) => `dischargeRecordsElement: ${point}`).join('\n')
+        : 'dischargeRecords does not contain any elements',
+    );
+    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 VesselSphereCatastrophicRuptureCalculationResponse extends CalculationResponseBase {
+  exitMaterial: Entities.Material;
+  dischargeResult: Entities.DischargeResult;
+  dischargeRecords: Entities.DischargeRecord[];
+
+  /**
+   * VesselSphereCatastrophicRupture calculation response class.
+   *
+   */
+  constructor(data: {
+    exitMaterial: Entities.Material;
+    dischargeResult: Entities.DischargeResult;
+    dischargeRecords: Entities.DischargeRecord[];
+    resultCode: Enums.ResultCode;
+    messages: string[];
+    calculationElapsedTime: number;
+    operationId: string;
+  }) {
+    super();
+    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 }) {
+    if (data.exitMaterial) {
+      this.exitMaterial = new Entities.Material();
+      this.exitMaterial.initialiseFromDictionary(data.exitMaterial as { [key: string]: unknown });
+    }
+    if (data.dischargeResult) {
+      this.dischargeResult = new Entities.DischargeResult();
+      this.dischargeResult.initialiseFromDictionary(data.dischargeResult as { [key: string]: unknown });
+    }
+    if (data.dischargeRecords && Array.isArray(data.dischargeRecords)) {
+      this.dischargeRecords = data.dischargeRecords.map((item) => {
+        const record = new Entities.DischargeRecord();
+        record.initialiseFromDictionary(item);
+        return record;
+      });
+    }
+    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 VesselSphereCatastrophicRuptureCalculationResponseSchemaData {
+  exitMaterial: Entities.Material;
+  dischargeResult: Entities.DischargeResult;
+  dischargeRecords: Entities.DischargeRecord[];
+  resultCode: Enums.ResultCode;
+  messages: string[];
+  calculationElapsedTime: number;
+  operationId: string;
+}
+
+export class VesselSphereCatastrophicRuptureCalculationResponseSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the VesselSphereCatastrophicRupture calculation response.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      exitMaterial: new EntitySchemas.MaterialSchema().schema,
+      dischargeResult: new EntitySchemas.DischargeResultSchema().schema,
+      dischargeRecords: Joi.array().items(new EntitySchemas.DischargeRecordSchema().schema).allow(null),
+      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 = {
+      exitMaterial: 'Entities.Material',
+      dischargeResult: 'Entities.DischargeResult',
+      dischargeRecords: 'Entities.DischargeRecord[]',
+    };
+  }
+
+  validate(data: VesselSphereCatastrophicRuptureCalculationResponseSchemaData): VesselSphereCatastrophicRuptureCalculationResponse {
+    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: VesselSphereCatastrophicRuptureCalculationResponseSchemaData): VesselSphereCatastrophicRuptureCalculationResponse {
+    return new VesselSphereCatastrophicRuptureCalculationResponse(data);
+  }
+}
+
+export interface VesselSphereLeakCalculationRequestSchemaData {
+  vesselSphere: Entities.VesselSphere;
+  leak: Entities.Leak;
+  dischargeParameters: Entities.DischargeParameters;
+}
+
+class VesselSphereLeakCalculationRequest extends CalculationRequestBase {
+  vesselSphere: Entities.VesselSphere;
+  leak: Entities.Leak;
+  dischargeParameters: Entities.DischargeParameters;
+
+  /**
+   * VesselSphereLeak calculation request class.
+   *
+   */
+  constructor(data: { vesselSphere: Entities.VesselSphere; leak: Entities.Leak; dischargeParameters: Entities.DischargeParameters }) {
+    super();
+    this.vesselSphere = data.vesselSphere;
+    this.leak = data.leak;
+    this.dischargeParameters = data.dischargeParameters;
+  }
+}
+
+export class VesselSphereLeakCalculationRequestSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the VesselSphereLeak calculation request.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      vesselSphere: new EntitySchemas.VesselSphereSchema().schema,
+      leak: new EntitySchemas.LeakSchema().schema,
+      dischargeParameters: new EntitySchemas.DischargeParametersSchema().schema,
+    }).unknown(true);
+
+    this.propertyTypes = {
+      vesselSphere: 'Entities.VesselSphere',
+      leak: 'Entities.Leak',
+      dischargeParameters: 'Entities.DischargeParameters',
+    };
+  }
+
+  validate(data: VesselSphereLeakCalculationRequestSchemaData): VesselSphereLeakCalculationRequest {
+    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: VesselSphereLeakCalculationRequestSchemaData): VesselSphereLeakCalculationRequest {
+    return new VesselSphereLeakCalculationRequest(data);
+  }
+}
+
+export class VesselSphereLeakCalculation extends CalculationBase {
+  vesselSphere: Entities.VesselSphere;
+  leak: Entities.Leak;
+  dischargeParameters: Entities.DischargeParameters;
+  exitMaterial?: Entities.Material;
+  dischargeResult?: Entities.DischargeResult;
+  dischargeRecords?: Entities.DischargeRecord[];
+
+  /**
+   * Calculates the steady state or time varying leak from a spherical vessel. 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. * Note: Pressure as part of the state defined in vessel entity is in absolute units, this is to align with other uses of the state entity for which pressure gauge is not the right definition, i.e. the final state discharge, state specification for flash calculation, etc.
+   *
+   */
+  constructor(data: { vesselSphere: Entities.VesselSphere; leak: Entities.Leak; dischargeParameters: Entities.DischargeParameters; controller?: AbortController }) {
+    super(data.controller);
+    this.vesselSphere = data.vesselSphere;
+    this.leak = data.leak;
+    this.dischargeParameters = data.dischargeParameters;
+  }
+
+  async run() {
+    try {
+      const request = new VesselSphereLeakCalculationRequest({
+        vesselSphere: this.vesselSphere,
+        leak: this.leak,
+        dischargeParameters: this.dischargeParameters,
+      });
+
+      const schema = new VesselSphereLeakCalculationRequestSchema();
+      const validatedRequest = schema.validate(request);
+
+      const requestJson = JSON.stringify(validatedRequest);
+      const url = `${getAnalyticsApiTarget()}calculatevesselsphereleak?clientId=${getClientAliasId()}`;
+
+      this.resultCode = Enums.ResultCode.UNEXPECTED_APPLICATION_ERROR;
+
+      const { data } = await this.postRequest(url, requestJson);
+
+      const responseSchema = new VesselSphereLeakCalculationResponseSchema();
+      const validatedResponse = responseSchema.validate(data);
+
+      this.resultCode = validatedResponse.resultCode;
+      if (this.resultCode === Enums.ResultCode.SUCCESS) {
+        Object.assign(this, {
+          exitMaterial: validatedResponse.exitMaterial,
+          dischargeResult: validatedResponse.dischargeResult,
+          dischargeRecords: validatedResponse.dischargeRecords,
+          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 = ['* VesselSphereLeak'];
+
+    parts.push(`exitMaterial: ${String(this.exitMaterial)}`);
+    parts.push(`dischargeResult: ${String(this.dischargeResult)}`);
+    parts.push('*** dischargeRecords:');
+    parts.push(
+      this.dischargeRecords && this.dischargeRecords.length > 0
+        ? this.dischargeRecords.map((point) => `dischargeRecordsElement: ${point}`).join('\n')
+        : 'dischargeRecords does not contain any elements',
+    );
+    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 VesselSphereLeakCalculationResponse extends CalculationResponseBase {
+  exitMaterial: Entities.Material;
+  dischargeResult: Entities.DischargeResult;
+  dischargeRecords: Entities.DischargeRecord[];
+
+  /**
+   * VesselSphereLeak calculation response class.
+   *
+   */
+  constructor(data: {
+    exitMaterial: Entities.Material;
+    dischargeResult: Entities.DischargeResult;
+    dischargeRecords: Entities.DischargeRecord[];
+    resultCode: Enums.ResultCode;
+    messages: string[];
+    calculationElapsedTime: number;
+    operationId: string;
+  }) {
+    super();
+    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 }) {
+    if (data.exitMaterial) {
+      this.exitMaterial = new Entities.Material();
+      this.exitMaterial.initialiseFromDictionary(data.exitMaterial as { [key: string]: unknown });
+    }
+    if (data.dischargeResult) {
+      this.dischargeResult = new Entities.DischargeResult();
+      this.dischargeResult.initialiseFromDictionary(data.dischargeResult as { [key: string]: unknown });
+    }
+    if (data.dischargeRecords && Array.isArray(data.dischargeRecords)) {
+      this.dischargeRecords = data.dischargeRecords.map((item) => {
+        const record = new Entities.DischargeRecord();
+        record.initialiseFromDictionary(item);
+        return record;
+      });
+    }
+    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 VesselSphereLeakCalculationResponseSchemaData {
+  exitMaterial: Entities.Material;
+  dischargeResult: Entities.DischargeResult;
+  dischargeRecords: Entities.DischargeRecord[];
+  resultCode: Enums.ResultCode;
+  messages: string[];
+  calculationElapsedTime: number;
+  operationId: string;
+}
+
+export class VesselSphereLeakCalculationResponseSchema {
+  schema: Joi.ObjectSchema;
+  propertyTypes: Record<string, string>;
+
+  /**
+   * Schema for the VesselSphereLeak calculation response.
+   */
+  constructor() {
+    this.schema = Joi.object({
+      exitMaterial: new EntitySchemas.MaterialSchema().schema,
+      dischargeResult: new EntitySchemas.DischargeResultSchema().schema,
+      dischargeRecords: Joi.array().items(new EntitySchemas.DischargeRecordSchema().schema).allow(null),
+      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 = {
+      exitMaterial: 'Entities.Material',
+      dischargeResult: 'Entities.DischargeResult',
+      dischargeRecords: 'Entities.DischargeRecord[]',
+    };
+  }
+
+  validate(data: VesselSphereLeakCalculationResponseSchemaData): VesselSphereLeakCalculationResponse {
+    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: VesselSphereLeakCalculationResponseSchemaData): VesselSphereLeakCalculationResponse {
+    return new VesselSphereLeakCalculationResponse(data);
+  }
+}
+
 export interface VesselStateCalculationRequestSchemaData {
   material: Entities.Material;
   materialState: Entities.State;
@@ -1791,9 +2436,7 @@ export class VesselStateCalculation extends CalculationBase {
   outputState?: Entities.State;
 
   /**
-   * Calculates the fluid phase for a user-defined material where the user has defined the pressure and/or temperature. The model carries out a flash calculation to obtain the fluid properties. And returns 
-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.
+   * Calculates the fluid phase for a user-defined material where the user has defined the pressure and/or temperature. The model carries out a flash calculation to obtain the fluid properties and returns the vessel conditions (i.e. Pure gas, Stratified Two-Phase vessel, Pressurised Liquid) that can be input to the source term models: vessel leak and vessel catastrophic rupture.
    *
    */
   constructor(data: { material: Entities.Material; materialState: Entities.State; controller?: AbortController }) {