creditu-common-library 1.16.2 → 2.1.0

package/debt/models/dto/balances-output.dto.d.ts

@@ -1,10 +1,10 @@
 export declare class BalancesOutput {
     /**
-     * Arreglo de saldos insolutos diarios aplicando IPCA
+     * Arreglo de saldos insolutos diarios aplicando inflación
      */
     balances: number[];
     /**
-     * Arreglo de montos darios de IPCA
+     * Arreglo de montos darios de corrección monetaria
      */
     balanceMonetaryUpdateValues: number[];
 }

package/debt/models/dto/debt-inputs.dto.d.ts

@@ -28,7 +28,7 @@ export declare class DebtInputs {
      */
     previousBalance: PreviousBalance;
     /**
-     * Maximo de IPCA a pagar pactado con el cliente
+     * Maximo de inflación a pagar pactado con el cliente
      */
     inflationaryUpperBound: number;
     /**
@@ -36,15 +36,15 @@ export declare class DebtInputs {
      */
     propertyAmount: number;
     /**
-     * Mapa de IPCAs en el rango de fechas de la deuda a calcular
+     * Mapa de inflaciones en el rango de fechas de la deuda a calcular
      * Key: Date YYYY/MM/DD format, Value: number format
      */
-    IPCAmap: Record<string, number>;
+    inflationMap: Record<string, number>;
     /**
-     * Mapa de IPCAs en el rango de fechas de la mora a calcular
+     * Mapa de inflaciones en el rango de fechas de la mora a calcular
      * Key: Date YYYY/MM/DD format, Value: number format
      */
-    IPCAmapLate: Record<string, number>;
+    inflationMapLate: Record<string, number>;
     /**
      * Fecha a sobre la cuál se desea calcular la mora
      */

package/debt/models/dto/debt-params.dto.d.ts

@@ -1,4 +1,7 @@
+import { InterestType } from '../../../shared/models';
 import { CreditInsuranceRate } from '../../../shared/models/credit-insurance-rate';
+import { InsurancesStrategy } from '../../../shared/models/enum/insurances-strategy.enum';
+import { MonthNominalLength } from '../../../shared/models/enum/month-nominal-length.enum';
 /**
  * Parametros para el calculo de la Deuda
  */
@@ -27,4 +30,28 @@ export declare class DebtParams {
     * Tasa de multa mensual por atraso
     */
     lateChargesInterestRate?: number;
+    /**
+    * Comportamiento del largo del mes, por defecto es REAL
+    */
+    monthNominalLength?: number | MonthNominalLength;
+    /**
+    * Peridiocidad de los intereses, por defecto es Compuesta
+    */
+    inflationExchangeMethodMonthlyToDaily?: InterestType;
+    /**
+    * Peridiocidad de los intereses, por defecto es Compuesta
+    */
+    inflationExchangeMethodYearlyToMonthly?: InterestType;
+    /**
+     * Estrategia a usar para el calculo de los seguros.
+     * Por defecto es PERIODS, que es el cálculo que ya veníamos haciendo.
+     * La alternativa es BALANCES, que es el cálculo que se hace en el Excel "Producto_LowCode-Desarrollo"
+     */
+    insurancesStrategy?: InsurancesStrategy;
+    /**
+     * Indica si se hace algún pago durante los meses de gracia
+     * Por defecto es true
+     */
+    hasGracePeriodAnyPayment?: boolean;
+    constructor(params: DebtParams);
 }

package/debt/models/dto/debt-params.dto.js

@@ -1,11 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DebtParams = void 0;
+var models_1 = require("../../../shared/models");
+var insurances_strategy_enum_1 = require("../../../shared/models/enum/insurances-strategy.enum");
+var month_nominal_length_enum_1 = require("../../../shared/models/enum/month-nominal-length.enum");
 /**
  * Parametros para el calculo de la Deuda
  */
 var DebtParams = /** @class */ (function () {
-    function DebtParams() {
+    function DebtParams(params) {
+        var _this = this;
+        /**
+        * Comportamiento del largo del mes, por defecto es REAL
+        */
+        this.monthNominalLength = month_nominal_length_enum_1.MonthNominalLength.REAL;
+        /**
+        * Peridiocidad de los intereses, por defecto es Compuesta
+        */
+        this.inflationExchangeMethodMonthlyToDaily = models_1.InterestType.COMPOUND;
+        /**
+        * Peridiocidad de los intereses, por defecto es Compuesta
+        */
+        this.inflationExchangeMethodYearlyToMonthly = models_1.InterestType.COMPOUND;
+        /**
+         * Estrategia a usar para el calculo de los seguros.
+         * Por defecto es PERIODS, que es el cálculo que ya veníamos haciendo.
+         * La alternativa es BALANCES, que es el cálculo que se hace en el Excel "Producto_LowCode-Desarrollo"
+         */
+        this.insurancesStrategy = insurances_strategy_enum_1.InsurancesStrategy.PERIODS;
+        /**
+         * Indica si se hace algún pago durante los meses de gracia
+         * Por defecto es true
+         */
+        this.hasGracePeriodAnyPayment = true;
+        Object.entries(params).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            _this[key] = value;
+        });
     }
     return DebtParams;
 }());

package/debt/models/dto/debt-response.dto.d.ts

@@ -1,19 +1,19 @@
 import { BalancesOutput } from './balances-output.dto';
-import { DailyIPCAOutput } from './daily-ipca-output.dto';
+import { InflationByDates } from './inflation-by-dates.dto';
 /**
  * Respuesta del calculo de la deuda
  */
 export declare class DebtResponse {
-    /** IPCA diarios para las fechas de calculo de deuda */
-    IPCAByDates: DailyIPCAOutput[];
-    /** Saldos calculados en base al IPCA */
+    /** Inflación diaria para las fechas de calculo de deuda */
+    inflationByDates: InflationByDates[];
+    /** Saldos calculados aplicando inflación */
     balanceValues: BalancesOutput;
     /** Saldo insoluto corregido por inflación */
     balanceInflationaryUpdated: number;
     /** Saldo total despues del pago */
     balanceAfter: number;
-    /** Monto total a pagar por concepto de IPCA */
-    ipcaUpdate: number;
+    /** Monto total a pagar por concepto de inflación */
+    inflationaryUpdate: number;
     /** Interés sin inflación */
     interest: number;
     /** Diferencia entre interés sin corrección monetaria y con */
@@ -37,7 +37,7 @@ export declare class DebtResponse {
     /** amortización de capital que se aplicará finalmente */
     amortization: number;
     /** amortización teórica por concepto de inflación */
-    amortizationIPCA: number;
+    amortizationInflation: number;
     /** Cuota de seguro de vida o desgravamen */
     totalLifeInsuranceFee: number;
     /** Cuota de seguro de vida o desgravamen aplicado al deudor */

package/debt/models/dto/inflation-by-dates.dto.d.ts

@@ -0,0 +1,14 @@
+export declare class InflationByDates {
+    /**
+     * Fecha formato YYYY/MM/DD
+     */
+    date: string;
+    /**
+     * Valor de la inflación para el mes de la fecha
+     */
+    inflation: number;
+    /**
+     * Valor de la inflación para el dia
+     */
+    dailyInflation: number;
+}

package/debt/models/dto/inflation-by-dates.dto.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InflationByDates = void 0;
+var InflationByDates = /** @class */ (function () {
+    function InflationByDates() {
+    }
+    return InflationByDates;
+}());
+exports.InflationByDates = InflationByDates;

package/debt/models/lates-input.dto.d.ts

@@ -1,3 +1,5 @@
+import { InterestType } from '../../shared/models';
+import { MonthNominalLength } from '../../shared/models/enum/month-nominal-length.enum';
 export declare class LatesInput {
     dueDate: string;
     today: string;
@@ -7,4 +9,6 @@ export declare class LatesInput {
     annualCreditInterestRate: number;
     inflationMap: Record<string, number>;
     considerNegativeInflation: boolean;
+    monthNominalLength: number | MonthNominalLength;
+    inflationExchangeMethodYearlyToMonthly: InterestType;
 }

package/debt/services/amortization.service.d.ts

@@ -1,51 +1,45 @@
 import { MathService } from '../../math';
-import { NumberOfMonths } from '../../shared/models/number-of-months';
-import { PaymentNumber } from '../../shared/models/payment-number';
 import { DebtInputs } from '../models/dto';
 export declare class AmortizationService {
     private readonly math;
     constructor(math: MathService);
-    private readonly ipcaService;
+    private readonly inflationService;
     private readonly interestService;
     private getMonthlyPayment;
-    private getAmortizationDiffGerman;
     /**
      *
      * @param monthlyRate Tasa mensual del crédito
-     * @param numberOfMonths Número de meses del crédito
-     * @param previusBalance Balance anterior
+     * @param periods Cantidad de cuotas restantes
      * @param balance Balance actual
-     * @param paymentNumber Número de cuota
      * @returns
      */
-    private getAmortizationDiffFrench;
+    private getAmortizationFrench;
     /**
      *
      * @param monthlyRate Tasa mensual del crédito
-     * @param numberOfMonths Número de meses del crédito
+     * @param previusBalance Balance anterior
      * @param balance Balance actual
-     * @param paymentNumber Número de cuota
      * @returns
      */
-    private getAmortizationFrench;
+    private getAmortizationDiffFrench;
     /**
      * Calcula la amortizacion
-     * @param paymentNumber
-     * @param numberOfMonths
+     * @param periods
      * @param balance
      */
-    getAmortizationGerman(paymentNumber: PaymentNumber, numberOfMonths: NumberOfMonths, balance: number): number;
+    getAmortizationGerman(periods: number, balance: number): number;
+    private getAmortizationDiffGerman;
     getAmortizationIUB(inputs: any, balance: any, annualRate: any): {
         amortizationIUB: any;
         amortizationDiff: any;
     };
-    getAmortization(amortizationIUB: number, postponedInflationaryUpdate: number, amortizationDiff: number): number;
-    getAmortizationIPC(upperBound: number, amortizationDiff: number, IPCAupdate: number): number;
-    getAmortizations(inputs: DebtInputs, balance: number, annualRate: number, balanceMonetaryUpdateValues: number[]): {
-        ipcaUpdate: number;
+    getAmortization(amortizationIUB: number, amortizationDiff: number, postponedInflationaryUpdate: number): number;
+    getAmortizationInflation(upperBound: number, amortizationDiff: number, inflationaryUpdate: number): number;
+    getAmortizations(inputs: DebtInputs, balance: number, annualRate: number, inflationaryUpdate: number): {
+        inflationaryUpdate: number;
         upperBound: number;
         postponedInflationaryUpdate: number;
-        amortizationIPCA: number;
+        amortizationInflation: number;
         amortization: number;
         amortizationIUB: any;
         amortizationDiff: any;

package/debt/services/amortization.service.js

@@ -5,11 +5,11 @@ var math_1 = require("../../math");
 var guarder_1 = require("../../shared/models/guarder");
 var models_1 = require("../../shared/models");
 var interest_service_1 = require("./interest.service");
-var ipca_service_1 = require("./ipca.service");
+var inflation_service_1 = require("./inflation.service");
 var AmortizationService = /** @class */ (function () {
     function AmortizationService(math) {
         this.math = math;
-        this.ipcaService = new ipca_service_1.IPCAService(this.math);
+        this.inflationService = new inflation_service_1.InflationService(this.math);
         this.interestService = new interest_service_1.InterestService(this.math);
         this.math = new math_1.MathService(true, 10);
     }
@@ -19,96 +19,86 @@ var AmortizationService = /** @class */ (function () {
         var periodRate = this.math.subtract(periodInterest, 1);
         return this.math.multiply(this.math.divide(interest, periodRate), balance);
     };
-    AmortizationService.prototype.getAmortizationDiffGerman = function (previousBalance, balance, numberOfMonths) {
-        return this.math.round(this.math.divide(this.math.subtract(balance, previousBalance), numberOfMonths), 10);
-    };
     /**
      *
      * @param monthlyRate Tasa mensual del crédito
-     * @param numberOfMonths Número de meses del crédito
-     * @param previusBalance Balance anterior
+     * @param periods Cantidad de cuotas restantes
      * @param balance Balance actual
-     * @param paymentNumber Número de cuota
      * @returns
      */
-    AmortizationService.prototype.getAmortizationDiffFrench = function (monthlyRate, period, previusBalance, balance) {
-        // const period = this.math.subtract(this.math.add(numberOfMonths, 1), paymentNumber);
-        var initialMonthlyPayment = this.getMonthlyPayment(monthlyRate, period, previusBalance);
-        var initialInterest = this.math.multiply(previusBalance, monthlyRate);
-        var initialMonthlyAmortization = this.math.subtract(initialMonthlyPayment, initialInterest);
-        var finalMonthlyPayment = this.getMonthlyPayment(monthlyRate, period, balance);
+    AmortizationService.prototype.getAmortizationFrench = function (monthlyRate, periods, balance) {
+        var monthlyPayment = this.getMonthlyPayment(monthlyRate, periods, balance);
         var interest = this.math.multiply(balance, monthlyRate);
-        var finalMonthlyAmortization = this.math.subtract(finalMonthlyPayment, interest);
-        return this.math.subtract(finalMonthlyAmortization, initialMonthlyAmortization);
+        return this.math.subtract(monthlyPayment, interest);
     };
     /**
      *
      * @param monthlyRate Tasa mensual del crédito
-     * @param numberOfMonths Número de meses del crédito
+     * @param previusBalance Balance anterior
      * @param balance Balance actual
-     * @param paymentNumber Número de cuota
      * @returns
      */
-    AmortizationService.prototype.getAmortizationFrench = function (monthlyRate, period, balance) {
-        // const period = this.math.subtract(this.math.add(numberOfMonths, 1), paymentNumber);
-        var monthlyPayment = this.getMonthlyPayment(monthlyRate, period, balance);
-        var interest = this.math.multiply(balance, monthlyRate);
-        return this.math.subtract(monthlyPayment, interest);
+    AmortizationService.prototype.getAmortizationDiffFrench = function (monthlyRate, periods, previusBalance, balance) {
+        var initialMonthlyAmortization = this.getAmortizationFrench(monthlyRate, periods, previusBalance);
+        var finalMonthlyAmortization = this.getAmortizationFrench(monthlyRate, periods, balance);
+        return this.math.subtract(finalMonthlyAmortization, initialMonthlyAmortization);
     };
     /**
      * Calcula la amortizacion
-     * @param paymentNumber
-     * @param numberOfMonths
+     * @param periods
      * @param balance
      */
-    AmortizationService.prototype.getAmortizationGerman = function (paymentNumber, numberOfMonths, balance) {
-        guarder_1.Guarder.defined(paymentNumber, 'PaymentNumber');
-        guarder_1.Guarder.defined(numberOfMonths, 'NumberOfMonths');
-        if (balance === undefined || balance < 0 || balance === null)
-            throw new Error('invalid balance on Amortization calculation');
-        var divisor = numberOfMonths.value() - paymentNumber.value() + 1;
-        var result = this.math.divide(balance, divisor);
+    AmortizationService.prototype.getAmortizationGerman = function (periods, balance) {
+        guarder_1.Guarder.defined(periods, 'Periods');
+        guarder_1.Guarder.validNumber(periods, 'Periods');
+        guarder_1.Guarder.noNegativeNumber(periods, 'Periods');
+        guarder_1.Guarder.defined(balance, 'Balance');
+        guarder_1.Guarder.validNumber(balance, 'Balance');
+        guarder_1.Guarder.noNegativeNumber(balance, 'Balance');
+        var result = this.math.divide(balance, periods);
         return result;
     };
+    AmortizationService.prototype.getAmortizationDiffGerman = function (previousBalance, balance, periods) {
+        return this.math.round(this.math.divide(this.math.subtract(balance, previousBalance), periods), 10);
+    };
     AmortizationService.prototype.getAmortizationIUB = function (inputs, balance, annualRate) {
         if (inputs.isGraceMonth) {
             return { amortizationIUB: 0, amortizationDiff: 0 };
         }
         var amortizationIUB;
         var amortizationDiff;
-        var period = this.math.subtract(this.math.add(inputs.numberOfMonths.value(), 1), inputs.paymentNumber.value());
+        var periods = this.math.subtract(this.math.add(inputs.numberOfMonths.value(), 1), inputs.paymentNumber.value());
         if (inputs.amortizationMethod === models_1.AmortizationMethod.GERMAN) {
-            amortizationIUB = this.getAmortizationGerman(inputs.paymentNumber, inputs.numberOfMonths, balance);
-            amortizationDiff = this.getAmortizationDiffGerman(inputs.previousBalance.value(), balance, period);
+            amortizationIUB = this.getAmortizationGerman(periods, balance);
+            amortizationDiff = this.getAmortizationDiffGerman(inputs.previousBalance.value(), balance, periods);
         }
         else if (inputs.amortizationMethod === models_1.AmortizationMethod.FRENCH) {
             var monthlyRate = this.interestService.getMonthlyInterestValue(annualRate);
-            amortizationIUB = this.getAmortizationFrench(monthlyRate, period, balance);
-            amortizationDiff = this.getAmortizationDiffFrench(monthlyRate, period, inputs.previousBalance.value(), balance);
+            amortizationIUB = this.getAmortizationFrench(monthlyRate, periods, balance);
+            amortizationDiff = this.getAmortizationDiffFrench(monthlyRate, periods, inputs.previousBalance.value(), balance);
         }
         return { amortizationIUB: amortizationIUB, amortizationDiff: amortizationDiff };
     };
-    AmortizationService.prototype.getAmortization = function (amortizationIUB, postponedInflationaryUpdate, amortizationDiff) {
-        return this.math.subtract(amortizationIUB, postponedInflationaryUpdate, amortizationDiff);
+    AmortizationService.prototype.getAmortization = function (amortizationIUB, amortizationDiff, postponedInflationaryUpdate) {
+        return this.math.subtract(amortizationIUB, amortizationDiff, postponedInflationaryUpdate);
     };
-    AmortizationService.prototype.getAmortizationIPC = function (upperBound, amortizationDiff, IPCAupdate) {
-        var amortizationIPCA = this.math.round(upperBound < IPCAupdate
+    AmortizationService.prototype.getAmortizationInflation = function (upperBound, amortizationDiff, inflationaryUpdate) {
+        var amortizationInflation = this.math.round(upperBound < inflationaryUpdate
             ? this.math.subtract(upperBound, amortizationDiff)
-            : this.math.subtract(IPCAupdate, amortizationDiff), 10);
-        return amortizationIPCA < 0 ? 0 : amortizationIPCA;
+            : this.math.subtract(inflationaryUpdate, amortizationDiff), 10);
+        return amortizationInflation < 0 ? 0 : amortizationInflation;
     };
-    AmortizationService.prototype.getAmortizations = function (inputs, balance, annualRate, balanceMonetaryUpdateValues) {
+    AmortizationService.prototype.getAmortizations = function (inputs, balance, annualRate, inflationaryUpdate) {
         var _a = this.getAmortizationIUB(inputs, balance, annualRate), amortizationIUB = _a.amortizationIUB, amortizationDiff = _a.amortizationDiff;
-        var ipcaUpdate = this.ipcaService.getIPCAUpdate(balanceMonetaryUpdateValues);
         var upperBound = this.math.multiply(inputs.previousBalance.value(), inputs.inflationaryUpperBound);
-        var amortizationIPCA = this.getAmortizationIPC(upperBound, amortizationDiff, ipcaUpdate);
-        var postponedInflationaryUpdate = this.ipcaService.getPosponedInflationaryUpdate(upperBound, ipcaUpdate, inputs.upperBoundBehaviour);
-        var amortization = this.getAmortization(amortizationIUB, postponedInflationaryUpdate, amortizationDiff);
+        var amortizationInflation = this.getAmortizationInflation(upperBound, amortizationDiff, inflationaryUpdate);
+        var postponedInflationaryUpdate = this.inflationService.getPosponedInflationaryUpdate(upperBound, inflationaryUpdate, inputs.upperBoundBehaviour);
+        var amortization = this.getAmortization(amortizationIUB, amortizationDiff, postponedInflationaryUpdate);
         return {
-            ipcaUpdate: ipcaUpdate,
+            inflationaryUpdate: inflationaryUpdate,
             upperBound: upperBound,
             postponedInflationaryUpdate: postponedInflationaryUpdate,
-            amortizationIPCA: amortizationIPCA,
+            amortizationInflation: amortizationInflation,
             amortization: amortization,
             amortizationIUB: amortizationIUB,
             amortizationDiff: amortizationDiff

package/debt/services/balance.service.d.ts

@@ -1,25 +1,27 @@
 import { MathService } from '../../math/math.service';
 import { BalancesOutput } from '../models/dto/balances-output.dto';
 import { PreviousBalance } from '../../shared/models/previous-balance';
+import { InflationByDates } from '../models/dto/inflation-by-dates.dto';
+import { InterestType } from '../../shared/models';
 export declare class BalanceService {
     private readonly math;
     constructor(math: MathService);
     /**
-     * Calcula los balances diarios aplicados con IPCA
-     * @param dailyIPCAvalues
+     * Calcula los balances diarios aplicados con inflación
+     * @param dailyInflationValues
      * @param dailyInflationaryUpperBound
      * @param previousBalance
      */
-    getBalances(dailyIPCAvalues: number[], previousBalance: PreviousBalance, considerNegativeInflation: boolean): BalancesOutput;
+    getBalances(inflationByDates: InflationByDates[], previousBalance: PreviousBalance, considerNegativeInflation: boolean, inflationExchangeMethodMonthlyToDaily?: InterestType): BalancesOutput;
     /**
      * Calcula el balance despues del pago
-     * previousBalance + IPCAupdate - amortizationIPC -amortization
+     * previousBalance + inflationUpdate - amortizationInflation -amortization
      * @param balance
-     * @param ipcaUpdate
+     * @param inflationaryUpdate
      * @param amortization
-     * @param amortizationIPCA
+     * @param amortizationInflation
      */
-    getBalanceAfter(previousBalance: PreviousBalance, ipcaUpdate: number, amortization: number, amortizationIPCA: number): number;
+    getBalanceAfter(previousBalance: PreviousBalance, inflationaryUpdate: number, amortization: number, amortizationInflation: number): number;
     /**
      * Obtiene el balance de la cuota
      * @param balanceValues

package/debt/services/balance.service.js

@@ -3,35 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BalanceService = void 0;
 var math_service_1 = require("../../math/math.service");
 var guarder_1 = require("../../shared/models/guarder");
+var models_1 = require("../../shared/models");
 var BalanceService = /** @class */ (function () {
     function BalanceService(math) {
         this.math = math;
         this.math = new math_service_1.MathService(true, 10);
     }
     /**
-     * Calcula los balances diarios aplicados con IPCA
-     * @param dailyIPCAvalues
+     * Calcula los balances diarios aplicados con inflación
+     * @param dailyInflationValues
      * @param dailyInflationaryUpperBound
      * @param previousBalance
      */
-    BalanceService.prototype.getBalances = function (dailyIPCAvalues, previousBalance, considerNegativeInflation) {
+    BalanceService.prototype.getBalances = function (inflationByDates, previousBalance, considerNegativeInflation, inflationExchangeMethodMonthlyToDaily) {
         var _this = this;
-        if (dailyIPCAvalues === undefined || dailyIPCAvalues.length === 0)
-            throw new Error('invalid dailyIPCAvalues on Balances calculation');
+        if (inflationExchangeMethodMonthlyToDaily === void 0) { inflationExchangeMethodMonthlyToDaily = models_1.InterestType.COMPOUND; }
+        if (inflationByDates === undefined || inflationByDates.length === 0) {
+            throw new Error('invalid inflationByDates on Balances calculation');
+        }
         guarder_1.Guarder.defined(previousBalance, 'PreviousBalance');
         if (previousBalance.value() < 0)
             throw new Error('invalid previousBalance on Balances calculation');
+        var dailyInflationvalues = inflationByDates
+            .map(function (obj) { return obj.dailyInflation; })
+            .slice(1);
         var balances = [previousBalance.value()];
         var balanceMonetaryUpdateValues = [];
-        dailyIPCAvalues.forEach(function (dailyIPCA) {
-            var previusBalanceUsed = balances[balances.length - 1];
-            if (dailyIPCA < 0 && considerNegativeInflation === false) {
-                // eslint-disable-next-line no-param-reassign
-                dailyIPCA = 0;
-            }
-            var balanceMonetaryUpdate = _this.math.multiply(dailyIPCA, previusBalanceUsed);
+        dailyInflationvalues.forEach(function (dailyInflationValue) {
+            var dailyInflation = (dailyInflationValue < 0 && !considerNegativeInflation) ? 0 : dailyInflationValue;
+            var actualBalance = balances[balances.length - 1];
+            var balanceToUpdate = {
+                SIMPLE: previousBalance.value(),
+                COMPOUND: actualBalance
+            }[inflationExchangeMethodMonthlyToDaily];
+            var balanceMonetaryUpdate = _this.math.multiply(dailyInflation, balanceToUpdate);
             balanceMonetaryUpdateValues.push(balanceMonetaryUpdate);
-            balances.push(_this.math.add(balanceMonetaryUpdate, previusBalanceUsed));
+            balances.push(_this.math.add(balanceMonetaryUpdate, actualBalance));
         });
         balances.splice(0, 1);
         return {
@@ -41,23 +48,26 @@ var BalanceService = /** @class */ (function () {
     };
     /**
      * Calcula el balance despues del pago
-     * previousBalance + IPCAupdate - amortizationIPC -amortization
+     * previousBalance + inflationUpdate - amortizationInflation -amortization
      * @param balance
-     * @param ipcaUpdate
+     * @param inflationaryUpdate
      * @param amortization
-     * @param amortizationIPCA
+     * @param amortizationInflation
      */
-    BalanceService.prototype.getBalanceAfter = function (previousBalance, ipcaUpdate, amortization, amortizationIPCA) {
+    BalanceService.prototype.getBalanceAfter = function (previousBalance, inflationaryUpdate, amortization, amortizationInflation) {
         guarder_1.Guarder.defined(previousBalance, 'PreviousBalance');
-        if (ipcaUpdate === undefined || ipcaUpdate === null)
-            throw new Error('invalid ipcaUpdate on BalanceAfter calculation');
-        if (amortization === undefined || amortization === null)
+        if (inflationaryUpdate === undefined || inflationaryUpdate === null) {
+            throw new Error('invalid inflationaryUpdate on BalanceAfter calculation');
+        }
+        if (amortization === undefined || amortization === null) {
             throw new Error('invalid amortization on BalanceAfter calculation');
-        if (amortizationIPCA === undefined || amortizationIPCA === null)
-            throw new Error('invalid amortizationIPCA on BalanceAfter calculation');
+        }
+        if (amortizationInflation === undefined || amortizationInflation === null) {
+            throw new Error('invalid amortizationInflation on BalanceAfter calculation');
+        }
         var result = this.math.subtract(previousBalance.value(), amortization);
-        result = this.math.add(result, ipcaUpdate);
-        result = this.math.subtract(result, amortizationIPCA);
+        result = this.math.add(result, inflationaryUpdate);
+        result = this.math.subtract(result, amortizationInflation);
         return result;
     };
     /**

package/debt/services/index.d.ts

@@ -1,8 +1,8 @@
 import { AmortizationService } from './amortization.service';
 import { InsuranceService } from './insurance.service';
-import { IPCAService } from './ipca.service';
+import { InflationService } from './inflation.service';
 import { MonthlyPaymentService } from './monthly-payment.service';
 import { InterestService } from './interest.service';
 import { InstallmentService } from './installment.service';
 import { LateService } from './late.service';
-export { AmortizationService, InsuranceService, IPCAService, MonthlyPaymentService, InterestService, InstallmentService, LateService };
+export { AmortizationService, InsuranceService, InflationService, MonthlyPaymentService, InterestService, InstallmentService, LateService };

package/debt/services/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LateService = exports.InstallmentService = exports.InterestService = exports.MonthlyPaymentService = exports.IPCAService = exports.InsuranceService = exports.AmortizationService = void 0;
+exports.LateService = exports.InstallmentService = exports.InterestService = exports.MonthlyPaymentService = exports.InflationService = exports.InsuranceService = exports.AmortizationService = void 0;
 var amortization_service_1 = require("./amortization.service");
 Object.defineProperty(exports, "AmortizationService", { enumerable: true, get: function () { return amortization_service_1.AmortizationService; } });
 var insurance_service_1 = require("./insurance.service");
 Object.defineProperty(exports, "InsuranceService", { enumerable: true, get: function () { return insurance_service_1.InsuranceService; } });
-var ipca_service_1 = require("./ipca.service");
-Object.defineProperty(exports, "IPCAService", { enumerable: true, get: function () { return ipca_service_1.IPCAService; } });
+var inflation_service_1 = require("./inflation.service");
+Object.defineProperty(exports, "InflationService", { enumerable: true, get: function () { return inflation_service_1.InflationService; } });
 var monthly_payment_service_1 = require("./monthly-payment.service");
 Object.defineProperty(exports, "MonthlyPaymentService", { enumerable: true, get: function () { return monthly_payment_service_1.MonthlyPaymentService; } });
 var interest_service_1 = require("./interest.service");

package/debt/services/inflation.service.d.ts

@@ -0,0 +1,30 @@
+import { MathService } from '../../math';
+import { InflationByDates } from '../models/dto/inflation-by-dates.dto';
+import { BehaviourCAP } from '../../shared/models/enum/behaviour-cap.enum';
+import { InterestType } from '../../shared/models';
+import { MonthNominalLength } from '../../shared/models/enum/month-nominal-length.enum';
+export declare class InflationService {
+    private readonly math;
+    constructor(math: MathService);
+    private readonly interestService;
+    private calculateDaysOfMonth;
+    /**
+     * Permite obtener la inflación diaria desde la fecha inicio y fecha final del inflationMap
+     * @param inflationMap
+     */
+    getInflationByDates(inflationMap: Record<string, number>, monthNominalLength?: number | MonthNominalLength, inflationExchangeMethodMonthlyToDaily?: InterestType): InflationByDates[];
+    getLastInflationaryBoundDifference(inflationaryBoundDifferenceValues: number[]): number;
+    /**
+     * Obtiene corrección monetaria
+     * @param inflationUpdateValues
+     */
+    getInflationaryUpdate(inflationUpdateValues: number[]): number;
+    /**
+     * @param previusBalance Balance de la cuota anterior
+     * @param inflationaryUpperBound Tope máximo que el cliente está dispuesto a pagar
+     * @param inflationaryUpdate Correción monetaria del balance por inflación
+     * @param amortizationDiff ...
+     */
+    getPosponedInflationaryUpdate(upperBound: number, inflationaryUpdate: number, upperBoundBehaviour: BehaviourCAP | undefined): number;
+    getDailyInflationValues(inflationByDates: InflationByDates[]): number[];
+}