solvx_reservoir_tools/src/index.ts

Client library for SolvxAI Reservoir Engineering Tools - Property of Nexa Consulting Services

import axios, { AxiosInstance } from 'axios';

export interface SolvxaiClientConfig {
  baseUrl: string;
  apiKey: string;
}

export class SolvxaiClient {
  private client: AxiosInstance;

  constructor(config: SolvxaiClientConfig) {
    this.client = axios.create({
      baseURL: config.baseUrl,
      headers: {
        'X-API-Key': config.apiKey,
        'Content-Type': 'application/json'
      }
    });
  }

  /**
   * Calculates all PVT (Pressure-Volume-Temperature) properties for a given set of reservoir conditions
   * @param params Object containing reservoir parameters:
   * - reservoir_temperature: Reservoir temperature in °F
   * - reservoir_pressure: Reservoir pressure in psia
   * - api_gravity: API gravity of the oil
   * - gas_specific_gravity: Specific gravity of the gas
   * - gas_oil_ratio: Gas-oil ratio in scf/STB (optional)
   * - bubble_point_pressure: Bubble point pressure in psia (optional)
   * - h2s_content: H2S content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - n2_content: N2 content in mole fraction (optional)
   * - water_salinity: Water salinity in ppm (optional)
   * - correlations: Custom correlation settings (optional)
   * @returns Promise containing calculated PVT properties
   */
  async calculatePvtProperties(params: {
    reservoir_temperature: number;
    reservoir_pressure: number;
    api_gravity: number;
    gas_specific_gravity: number;
    gas_oil_ratio?: number;
    bubble_point_pressure?: number;
    h2s_content?: number;
    co2_content?: number;
    n2_content?: number;
    water_salinity?: number;
    correlations?: any;
  }) {
    const response = await this.client.post('/api/pvt/calculateallproperties', params);
    return response.data;
  }

  /**
   * Calculates bubble point pressure from gas-oil ratio using specified correlation
   * @param params Object containing calculation parameters:
   * - correlation: Name of the correlation to use
   * - initial_gor: Initial gas-oil ratio in scf/STB
   * - gas_gravity: Gas specific gravity
   * - api: API gravity of the oil
   * - temperature: Temperature in °F
   * - nitrogen_percentage: Nitrogen content in mole fraction (optional)
   * @returns Promise containing calculated bubble point pressure
   */
  async calculatePbFromGor(params: {
    correlation: string;
    initial_gor: number;
    gas_gravity: number;
    api: number;
    temperature: number;
    nitrogen_percentage?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatepbfromgor', params);
    return response.data;
  }

  /**
   * Calculates gas-oil ratio from bubble point pressure using specified correlation
   * @param params Object containing calculation parameters:
   * - correlation: Name of the correlation to use
   * - pb: Bubble point pressure in psia
   * - gas_gravity: Gas specific gravity
   * - api: API gravity of the oil
   * - temperature: Temperature in °F
   * @returns Promise containing calculated gas-oil ratio
   */
  async calculateGorFromPb(params: {
    correlation: string;
    pb: number;
    gas_gravity: number;
    api: number;
    temperature: number;
  }) {
    const response = await this.client.post('/api/pvt/calculategorfrompb', params);
    return response.data;
  }

  /**
   * Calculates oil properties for given reservoir conditions
   * @param params Object containing reservoir parameters:
   * - reservoir_temperature: Reservoir temperature in °F
   * - pressure: Pressure in psia
   * - api_gravity: API gravity of the oil
   * - gas_specific_gravity: Specific gravity of the gas
   * - gas_oil_ratio: Gas-oil ratio in scf/STB (optional)
   * - bubble_point_pressure: Bubble point pressure in psia (optional)
   * - h2s_content: H2S content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - n2_content: N2 content in mole fraction (optional)
   * - correlations: Custom correlation settings (optional)
   * @returns Promise containing calculated oil properties
   */
  async calculateOilProperties(params: {
    reservoir_temperature: number;
    pressure: number;
    api_gravity: number;
    gas_specific_gravity: number;
    gas_oil_ratio?: number;
    bubble_point_pressure?: number;
    h2s_content?: number;
    co2_content?: number;
    n2_content?: number;
    correlations?: any;
  }) {
    const response = await this.client.post('/api/pvt/calculateoilproperties', params);
    return response.data;
  }

  /**
   * Calculates gas properties for given reservoir conditions
   * @param params Object containing reservoir parameters:
   * - reservoir_temperature: Reservoir temperature in °F
   * - pressure: Pressure in psia
   * - gas_specific_gravity: Specific gravity of the gas
   * - h2s_content: H2S content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - n2_content: N2 content in mole fraction (optional)
   * - correlations: Custom correlation settings (optional)
   * @returns Promise containing calculated gas properties
   */
  async calculateGasProperties(params: {
    reservoir_temperature: number;
    pressure: number;
    gas_specific_gravity: number;
    h2s_content?: number;
    co2_content?: number;
    n2_content?: number;
    correlations?: any;
  }) {
    const response = await this.client.post('/api/pvt/calculategasproperties', params);
    return response.data;
  }

  /**
   * Calculates water properties for given reservoir conditions
   * @param params Object containing reservoir parameters:
   * - reservoir_temperature: Reservoir temperature in °F
   * - pressure: Pressure in psia
   * - water_salinity: Water salinity in ppm (optional)
   * - correlations: Custom correlation settings (optional)
   * @returns Promise containing calculated water properties
   */
  async calculateWaterProperties(params: {
    reservoir_temperature: number;
    pressure: number;
    water_salinity?: number;
    correlations?: any;
  }) {
    const response = await this.client.post('/api/pvt/calculatewaterproperties', params);
    return response.data;
  }

  /**
   * Calculates bottom hole pressure (BHP) for given well conditions
   * @param params Object containing well parameters:
   * - mt_data: Measured depth and true vertical depth data
   * - annulus_data: Annulus flow and geometry data
   * - tubular_data: Tubing and casing dimensions
   * - temperature_data: Temperature profile data
   * - pvt_data: PVT properties data
   * - production_data: Production rates and pressures
   * - pvt_correlation_model: PVT correlation settings
   * @returns Promise containing calculated bottom hole pressure
   */
  async calculateBhp(params: {
    mt_data: {
      md: number[];
      tvd: number[];
    };
    annulus_data: {
      AnnulusFlow: number;
      VaryAnnulus: number;
      DepthVaryingAnnulus: number;
      TopCasingDia: number;
      AnTub: number;
    };
    tubular_data: {
      MDTubingShoe: number;
      CasingID: number;
      TubingID: number;
      TubingOD: number;
      Datum: number;
      piperough: number;
    };
    temperature_data: {
      md_temp: number[];
      temp: number[];
    };
    pvt_data: {
      API: number;
      GG: number;
      Salinity: number;
      MoleFraction_H2S?: number;
      MoleFraction_CO2?: number;
      MoleFraction_N2?: number;
      MoleFraction_H2O?: number;
      Cond?: number;
      correlation_name: string;
    };
    production_data: {
      qo: number;
      qw: number;
      qg: number;
      thp: number;
      chp: number;
    };
    pvt_correlation_model: {
      pvt_model: string;
      co_correlation: string;
      dead_oil_viscosity_correlation: string;
      saturated_oil_viscosity_correlation: string;
      undersaturated_oil_viscosity_correlation: string;
    };
  }) {
    const response = await this.client.post('/api/bhp/BHPcalculator', params);
    return response.data;
  }

  /**
   * Calculates interfacial tension using Ramey correlation
   * @param params Object containing fluid properties:
   * - rs: Solution gas-oil ratio in scf/STB
   * - api: API gravity of the oil
   * - gas_gravity: Gas specific gravity
   * - bo: Oil formation volume factor
   * - pressure: Pressure in psia
   * - temperature: Temperature in °F
   * - z: Gas compressibility factor
   * @returns Promise containing calculated interfacial tension
   */
  async calculateInterfacialTensionRamey(params: {
    rs: number;
    api: number;
    gas_gravity: number;
    bo: number;
    pressure: number;
    temperature: number;
    z: number;
  }) {
    const response = await this.client.post('/api/pvt/interfacialtension/ramey', params);
    return response.data;
  }

  /**
   * Calculates interfacial tension using Asheim correlation
   * @param params Object containing fluid properties:
   * - rs: Solution gas-oil ratio in scf/STB
   * - api: API gravity of the oil
   * - gas_gravity: Gas specific gravity
   * - bo: Oil formation volume factor
   * - pressure: Pressure in psia
   * - temperature: Temperature in °F
   * - z: Gas compressibility factor
   * @returns Promise containing calculated interfacial tension
   */
  async calculateInterfacialTensionAsheim(params: {
    rs: number;
    api: number;
    gas_gravity: number;
    bo: number;
    pressure: number;
    temperature: number;
    z: number;
  }) {
    const response = await this.client.post('/api/pvt/interfacialtension/asheim', params);
    return response.data;
  }

  /**
   * Calculates interfacial tension using Baker-Swerdloff correlation
   * @param params Object containing fluid properties:
   * - api: API gravity of the oil
   * - pressure: Pressure in psia
   * - temperature: Temperature in °F
   * @returns Promise containing calculated interfacial tension
   */
  async calculateInterfacialTensionBakerSwerdloff(params: {
    api: number;
    pressure: number;
    temperature: number;
  }) {
    const response = await this.client.post('/api/pvt/interfacialtension/bakerswerdloff', params);
    return response.data;
  }

  /**
   * Calculates oil-water interfacial tension
   * @param params Object containing fluid properties:
   * - api: API gravity of the oil
   * - temperature: Temperature in °F
   * - water_salinity: Water salinity in ppm
   * - gas_gravity: Gas specific gravity
   * - rs: Solution gas-oil ratio in scf/STB
   * - bo: Oil formation volume factor
   * - bw: Water formation volume factor
   * @returns Promise containing calculated oil-water interfacial tension
   */
  async calculateInterfacialTensionOilWater(params: {
    api: number;
    temperature: number;
    water_salinity: number;
    gas_gravity: number;
    rs: number;
    bo: number;
    bw: number;
  }) {
    const response = await this.client.post('/api/pvt/interfacialtension/oilwater', params);
    return response.data;
  }

  /**
   * Calculates gas-water interfacial tension
   * @param params Object containing fluid properties:
   * - pressure: Pressure in psia
   * - temperature: Temperature in °F
   * - water_salinity: Water salinity in ppm
   * - z_factor: Gas compressibility factor
   * - gas_gravity: Gas specific gravity
   * - bw: Water formation volume factor
   * @returns Promise containing calculated gas-water interfacial tension
   */
  async calculateInterfacialTensionGasWater(params: {
    pressure: number;
    temperature: number;
    water_salinity: number;
    z_factor: number;
    gas_gravity: number;
    bw: number;
  }) {
    const response = await this.client.post('/api/pvt/interfacialtension/gaswater', params);
    return response.data;
  }

  /**
   * Calculates compressibility using David-Yale correlation
   * @param params Object containing reservoir parameters:
   * - depth: Depth in feet
   * - reservoir_pressure: Reservoir pressure in psia
   * - pressure: Pressure in psia
   * @returns Promise containing calculated compressibility
   */
  async calculateCompressibilityDavidYale(params: {
    depth: number;
    reservoir_pressure: number;
    pressure: number;
  }) {
    const response = await this.client.post('/api/pvt/compressibility/davidyale', params);
    return response.data;
  }

  /**
   * Calculates compressibility using McCain correlation
   * @param params Object containing fluid properties:
   * - t_deg_f: Temperature in °F
   * - psia: Pressure in psia
   * - gor: Gas-oil ratio in scf/STB
   * - gas_grav: Gas specific gravity
   * - api: API gravity of the oil
   * - pb: Bubble point pressure in psia
   * - initial_gor: Initial gas-oil ratio in scf/STB
   * @returns Promise containing calculated compressibility
   */
  async calculateCompressibilityMcCain(params: {
    t_deg_f: number;
    psia: number;
    gor: number;
    gas_grav: number;
    api: number;
    pb: number;
    initial_gor: number;
  }) {
    const response = await this.client.post('/api/pvt/compressibility/mccain', params);
    return response.data;
  }

  /**
   * Calculates gas solubility in water using specified correlation
   * @param params Object containing parameters:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * @returns Promise containing calculated gas solubility in water
   */
  async calculateGasSolubilityInWater(params: {
    correlation: string;
    temperature: number;
    pressure: number;
  }) {
    const response = await this.client.post('/api/pvt/calculategassolubilityinwater', params);
    return response.data;
  }

  /**
   * Calculates gas density
   * @param params Object containing gas properties:
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - gas_gravity: Gas specific gravity
   * - n2_content: N2 content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - h2s_content: H2S content in mole fraction (optional)
   * @returns Promise containing calculated gas density
   */
  async calculateGasDensity(params: {
    temperature: number;
    pressure: number;
    gas_gravity: number;
    n2_content?: number;
    co2_content?: number;
    h2s_content?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculategasdensity', params);
    return response.data;
  }

  /**
   * Calculates gas viscosity using specified correlation
   * @param params Object containing gas properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - gas_gravity: Gas specific gravity
   * - h2s_content: H2S content in mole fraction (optional)
   * - n2_content: N2 content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * @returns Promise containing calculated gas viscosity
   */
  async calculateGasViscosity(params: {
    correlation: string;
    temperature: number;
    pressure: number;
    gas_gravity: number;
    h2s_content?: number;
    n2_content?: number;
    co2_content?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculategasviscosity', params);
    return response.data;
  }

  /**
   * Calculates gas compressibility using specified correlation
   * @param params Object containing gas properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - gas_gravity: Gas specific gravity
   * - n2_content: N2 content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - h2s_content: H2S content in mole fraction (optional)
   * @returns Promise containing calculated gas compressibility
   */
  async calculateGasCompressibility(params: {
    correlation: string;
    temperature: number;
    pressure: number;
    gas_gravity: number;
    n2_content?: number;
    co2_content?: number;
    h2s_content?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculategascompressibility', params);
    return response.data;
  }

  /**
   * Calculates gas formation volume factor using specified correlation
   * @param params Object containing gas properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - gas_gravity: Gas specific gravity
   * - n2_content: N2 content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - h2s_content: H2S content in mole fraction (optional)
   * @returns Promise containing calculated gas formation volume factor
   */
  async calculateGasFVF(params: {
    correlation: string;
    temperature: number;
    pressure: number;
    gas_gravity: number;
    n2_content?: number;
    co2_content?: number;
    h2s_content?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculategasfvf', params);
    return response.data;
  }

  /**
   * Calculates gas compressibility factor (Z-factor) using specified correlation
   * @param params Object containing gas properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - gas_gravity: Gas specific gravity
   * - n2_content: N2 content in mole fraction (optional)
   * - co2_content: CO2 content in mole fraction (optional)
   * - h2s_content: H2S content in mole fraction (optional)
   * @returns Promise containing calculated Z-factor
   */
  async calculateZFactor(params: {
    correlation: string;
    temperature: number;
    pressure: number;
    gas_gravity: number;
    n2_content?: number;
    co2_content?: number;
    h2s_content?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatezfactor', params);
    return response.data;
  }

  /**
   * Calculates water viscosity using specified correlation
   * @param params Object containing water properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia (optional)
   * - water_salinity: Water salinity in ppm (optional)
   * @returns Promise containing calculated water viscosity
   */
  async calculateWaterViscosity(params: {
    correlation: string;
    temperature: number;
    pressure?: number;
    water_salinity?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatewaterviscosity', params);
    return response.data;
  }

  /**
   * Calculates water compressibility using specified correlation
   * @param params Object containing water properties:
   * - correlation: Name of the correlation to use
   * - pressure: Pressure in psia
   * - temperature: Temperature in °F
   * @returns Promise containing calculated water compressibility
   */
  async calculateWaterCompressibility(params: {
    correlation: string;
    pressure: number;
    temperature: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatewatercompressibility', params);
    return response.data;
  }

  /**
   * Calculates water formation volume factor using specified correlation
   * @param params Object containing water properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * @returns Promise containing calculated water formation volume factor
   */
  async calculateWaterFVF(params: {
    correlation: string;
    temperature: number;
    pressure: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatewaterfvf', params);
    return response.data;
  }

  /**
   * Calculates oil compressibility using specified correlation
   * @param params Object containing oil properties:
   * - correlation: Name of the correlation to use
   * - api: API gravity of the oil
   * - pressure: Pressure in psia
   * - temperature: Temperature in °F
   * - gas_gravity: Gas specific gravity
   * - pb: Bubble point pressure in psia (optional)
   * - gor: Gas-oil ratio in scf/STB (optional)
   * @returns Promise containing calculated oil compressibility
   */
  async calculateOilCompressibility(params: {
    correlation: string;
    api: number;
    pressure: number;
    temperature: number;
    gas_gravity: number;
    pb?: number;
    gor?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculateoilcompressibility', params);
    return response.data;
  }

  /**
   * Calculates oil viscosity using specified correlations
   * @param params Object containing oil properties and correlation settings:
   * - dead_oil_correlation: Correlation for dead oil viscosity
   * - saturated_correlation: Correlation for saturated oil viscosity
   * - undersaturated_correlation: Correlation for undersaturated oil viscosity
   * - api: API gravity of the oil
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - gas_gravity: Gas specific gravity
   * - pb: Bubble point pressure in psia (optional)
   * - rs: Solution gas-oil ratio in scf/STB (optional)
   * @returns Promise containing calculated oil viscosity
   */
  async calculateOilViscosity(params: {
    dead_oil_correlation: string;
    saturated_correlation: string;
    undersaturated_correlation: string;
    api: number;
    temperature: number;
    pressure: number;
    gas_gravity: number;
    pb?: number;
    rs?: number;
  }) {
    const response = await this.client.post('/api/pvt/calculateoilviscosity', params);
    return response.data;
  }

  /**
   * Calculates oil formation volume factor using specified correlation
   * @param params Object containing oil properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - api: API gravity of the oil
   * - gas_gravity: Gas specific gravity
   * - pb: Bubble point pressure in psia (optional)
   * - initial_gor: Initial gas-oil ratio in scf/STB (optional)
   * - co_correlation: Correlation for solution gas-oil ratio (optional)
   * @returns Promise containing calculated oil formation volume factor
   */
  async calculateOilFVF(params: {
    correlation: string;
    temperature: number;
    pressure: number;
    api: number;
    gas_gravity: number;
    pb?: number;
    initial_gor?: number;
    co_correlation?: string;
  }) {
    const response = await this.client.post('/api/pvt/calculateoilfvf', params);
    return response.data;
  }

  /**
   * Calculates solution gas-oil ratio (Rs) using specified correlation
   * @param params Object containing oil properties:
   * - correlation: Name of the correlation to use
   * - temperature: Temperature in °F
   * - pressure: Pressure in psia
   * - api: API gravity of the oil
   * - gas_gravity: Gas specific gravity
   * - pb: Bubble point pressure in psia
   * @returns Promise containing calculated solution gas-oil ratio
   */
  async calculateRs(params: {
    correlation: string;
    temperature: number;
    pressure: number;
    api: number;
    gas_gravity: number;
    pb: number;
  }) {
    const response = await this.client.post('/api/pvt/calculaters', params);
    return response.data;
  }

  /**
   * Calculates pseudopressure for gas reservoirs
   * @param params Object containing reservoir properties:
   * - reservoir_pressure: Reservoir pressure in psia
   * - reservoir_temperature: Reservoir temperature in °F
   * - co2: CO2 content in mole fraction (optional)
   * - h2s: H2S content in mole fraction (optional)
   * - n2: N2 content in mole fraction (optional)
   * - correlation_for_gas_viscosity: Correlation for gas viscosity
   * - correlation_for_z_factor: Correlation for Z-factor
   * - gas_gravity: Gas specific gravity
   * @returns Promise containing calculated pseudopressure
   */
  async calculatePseudopressure(params: {
    reservoir_pressure: number;
    reservoir_temperature: number;
    co2?: number;
    h2s?: number;
    n2?: number;
    correlation_for_gas_viscosity: string;
    correlation_for_z_factor: string;
    gas_gravity: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatepseudopressure', params);
    return response.data;
  }

  /**
   * Retrieves available correlations for PVT calculations
   * @returns Promise containing list of available correlations
   */
  async getAvailableCorrelations() {
    const response = await this.client.get('/api/correlations-collection');
    return response.data;
  }

  /**
   * Checks the API status
   * @returns Promise containing API status information
   */
  async getApiStatus() {
    const response = await this.client.get('/api');
    return response.data;
  }

  /**
   * Calculates dead oil viscosity using specified correlation
   * @param params Object containing oil properties:
   * - correlation: Name of the correlation to use
   * - api: API gravity of the oil
   * - temperature: Temperature in °F
   * @returns Promise containing calculated dead oil viscosity
   */
  async calculateDeadOilViscosity(params: {
    correlation: string;
    api: number;
    temperature: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatedeadoilvisc', params);
    return response.data;
  }

  /**
   * Calculates saturated oil viscosity using specified correlation
   * @param params Object containing oil properties:
   * - correlation: Name of the correlation to use
   * - dead_oil_viscosity: Dead oil viscosity in cp
   * - rs: Solution gas-oil ratio in scf/STB
   * @returns Promise containing calculated saturated oil viscosity
   */
  async calculateSaturatedOilViscosity(params: {
    correlation: string;
    dead_oil_viscosity: number;
    rs: number;
  }) {
    const response = await this.client.post('/api/pvt/calculatesaturatedoilvisc', params);
    return response.data;
  }

  /**
   * Calculates undersaturated oil viscosity using specified correlation
   * @param params Object containing oil properties:
   * - correlation: Name of the correlation to use
   * - saturated_oil_viscosity: Saturated oil viscosity in cp
   * - api: API gravity of the oil
   * - pressure: Pressure in psia
   * - pb: Bubble point pressure in psia
   * @returns Promise containing calculated undersaturated oil viscosity
   */
  async calculateUndersaturatedOilViscosity(params: {
    correlation: string;
    saturated_oil_viscosity: number;
    api: number;
    pressure: number;
    pb: number;
  }) {
    const response = await this.client.post('/api/pvt/calculateundersaturatedoilvisc', params);
    return response.data;
  }

  /**
   * Calculates superposition time for multiple phase rates using specified flow regime
   * @param params Object containing:
   * - time: Array of time values
   * - phase_rates: Dictionary containing rate arrays for different phases (e.g., {"oil": [...], "gas": [...], "water": [...]})
   * - flow_regime: Flow regime type ('linear', 'bilinear', 'pss', or 'radial')
   * @returns Promise containing superposition time arrays for each phase
   */
  async calculateSuperpositionTime(params: {
    time: number[];
    phase_rates: Record<string, number[]>;
    flow_regime: string;
  }) {
    const response = await this.client.post('/api/rta/calculatesuperpositiontime', params);
    return response.data;
  }

  /**
   * Calculates derivatives for multiple phase rates using specified flow regime
   * @param params Object containing:
   * - time: Array of time values
   * - phase_rates: Dictionary containing rate arrays for different phases (e.g., {"oil": [...], "gas": [...], "water": [...]})
   * - pressure: Array of pressure values (common for all phases)
   * - flow_regime: Flow regime type ('linear', 'bilinear', 'pss', or 'radial')
   * - p_initial: Initial reservoir pressure
   * - fluid_p: List of fluid properties [Temp, Specific_Gravity, API, GOR, MoleFraction_H2S, MoleFraction_CO2, MoleFraction_N2, MoleFraction_H2O]
   * - s_ratio: Superposition time ratio for derivative calculation (optional, default is 4.0)
   * @returns Promise containing derivative arrays for each phase
   */
  async calculateDerivatives(params: {
    time: number[];
    phase_rates: Record<string, number[]>;
    pressure: number[];
    flow_regime: string;
    p_initial: number;
    fluid_p: number[];
    s_ratio?: number;
  }) {
    const response = await this.client.post('/api/rta/calculatederivatives', params);
    return response.data;
  }

  /**
   * Calculates superposition time for a single phase using specified flow regime
   * @param params Object containing:
   * - time: Array of time values
   * - rate: Array of rates for a single phase
   * - flow_regime: Flow regime type ('linear', 'bilinear', 'pss', or 'radial')
   * - phase_name: Optional name for the phase
   * @returns Promise containing array of superposition time values
   */
  async calculateSinglePhaseSuperpositionTime(params: {
    time: number[];
    rate: number[];
    flow_regime: string;
    phase_name?: string;
  }) {
    const response = await this.client.post('/api/rta/calculatesinglephasesuper', params);
    return response.data;
  }

  /**
   * Calculates derivatives for a single phase using specified flow regime
   * @param params Object containing:
   * - time: Array of time values
   * - rate: Array of rates for a single phase
   * - pressure: Array of pressure values
   * - flow_regime: Flow regime type ('linear', 'bilinear', 'pss', or 'radial')
   * - is_gas: True if gas phase, False if oil phase
   * - p_initial: Initial reservoir pressure
   * - fluid_p: List of fluid properties [Temp, Specific_Gravity, API, GOR, MoleFraction_H2S, MoleFraction_CO2, MoleFraction_N2, MoleFraction_H2O]
   * - s_ratio: Superposition time ratio for derivative calculation (optional, default is 4.0)
   * - phase_name: Optional name for the phase
   * @returns Promise containing array of derivative values
   */
  async calculateSinglePhaseDerivatives(params: {
    time: number[];
    rate: number[];
    pressure: number[];
    flow_regime: string;
    is_gas: boolean;
    p_initial: number;
    fluid_p: number[];
    s_ratio?: number;
    phase_name?: string;
  }) {
    const response = await this.client.post('/api/rta/calculatesinglephaseders', params);
    return response.data;
  }
}