@novha/calc-engines 6.3.0 → 7.0.1

package/test/spain-inheritance-tax.test.ts

@@ -0,0 +1,78 @@
+import { SpainInheritanceTaxServiceImpl } from '../src/inheritance-tax/spain/SpainInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/spain/domain/types';
+
+const spainRules: Rules = {
+    exemption: 0,
+    taxBrackets: [
+        { from: 0, to: 7993.46, rate: 0.0765 },
+        { from: 7993.46, to: 31956.34, rate: 0.102 },
+        { from: 31956.34, to: 79881.68, rate: 0.153 },
+        { from: 79881.68, to: 239389.13, rate: 0.2125 },
+        { from: 239389.13, to: 398777.54, rate: 0.255 },
+        { from: 398777.54, to: 797555.08, rate: 0.2975 },
+        { from: 797555.08, to: null, rate: 0.34 },
+    ],
+};
+
+describe('SpainInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for zero estate', () => {
+        const input: Input = { estateValue: 0 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+    });
+
+    it('returns zero tax when estate is at or below the exemption', () => {
+        const rulesWithExemption: Rules = { ...spainRules, exemption: 100000 };
+        const input: Input = { estateValue: 80000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, rulesWithExemption);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates tax for estate in first bracket', () => {
+        const input: Input = { estateValue: 5000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 0-5000: 5000 * 0.0765 = 382.5
+        expect(result.taxableEstate).toBe(5000);
+        expect(result.inheritanceTax).toBeCloseTo(382.5, 2);
+    });
+
+    it('correctly calculates tax for estate spanning multiple brackets', () => {
+        const input: Input = { estateValue: 100000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        // 0-7993.46: 7993.46 * 0.0765 ≈ 611.50
+        // 7993.46-31956.34: 23962.88 * 0.102 ≈ 2444.21
+        // 31956.34-79881.68: 47925.34 * 0.153 ≈ 7332.58
+        // 79881.68-100000: 20118.32 * 0.2125 ≈ 4275.14
+        // Total ≈ 14663.43
+        expect(result.taxableEstate).toBe(100000);
+        expect(result.inheritanceTax).toBeCloseTo(14663.43, 0);
+    });
+
+    it('effective rate equals inheritance tax divided by estate times 100', () => {
+        const input: Input = { estateValue: 100000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, spainRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBeCloseTo((result.inheritanceTax / 100000) * 100, 2);
+    });
+
+    it('taxable estate is reduced by the exemption amount', () => {
+        const rulesWithExemption: Rules = { ...spainRules, exemption: 20000 };
+        const input: Input = { estateValue: 50000 };
+        const service = new SpainInheritanceTaxServiceImpl(input, rulesWithExemption);
+        const result = service.calculate();
+
+        expect(result.taxableEstate).toBe(30000);
+    });
+});

package/test/spain-mortgage.test.ts

@@ -0,0 +1,70 @@
+import { SpainMortgageServiceImpl } from '../src/mortgage/spain/SpainMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/spain/domain/types';
+
+const spainRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.80, maxAmortizationYears: 30 },
+    interest: { compounding: 'MONTHLY' },
+    transferTax: { brackets: [{ above: 0, rate: 0.07 }] },
+};
+
+const input: MortgageInput = {
+    propertyPrice: 300000,
+    downPayment: 60000,
+    annualInterestRate: 3.5,
+    amortizationYears: 25,
+    isFirstTimeBuyer: false,
+};
+
+describe('SpainMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        // loanAmount = 300000 - 60000 = 240000
+        expect(result.loanAmount).toBe(240000);
+    });
+
+    it('correctly calculates transfer tax', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        // transferTax = (300000 - 0) * 0.07 = 21000
+        expect(result.transferTax).toBeCloseTo(21000, 2);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('total paid equals monthly payment multiplied by total payments', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        const expectedTotal = result.monthlyPayment * (input.amortizationYears * 12);
+        expect(result.totalPaid).toBeCloseTo(expectedTotal, 2);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new SpainMortgageServiceImpl();
+        const result = service.calculate(input, spainRules);
+
+        expect(result.amortizationSchedule).toHaveLength(25);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new SpainMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 300000 };
+
+        expect(() => service.calculate(badInput, spainRules)).toThrow();
+    });
+});

package/test/switzerland-corporate-tax.test.ts

@@ -0,0 +1,39 @@
+import { SwitzerlandCorporateTaxServiceImpl } from '../src/corporate/switzerland/SwitzerlandCorporateTaxServiceImpl';
+import { Input, Rules } from '../src/corporate/switzerland/domain/types';
+
+const switzerlandRules: Rules = {
+    regime: { type: 'flat', rate: 0.085 },
+};
+
+describe('SwitzerlandCorporateTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const input: Input = { taxableIncome: 0 };
+        const service = new SwitzerlandCorporateTaxServiceImpl(input, switzerlandRules);
+        const result = service.calculate();
+        expect(result.corporateTax).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('correctly applies the flat 8.5% rate', () => {
+        const input: Input = { taxableIncome: 1000000 };
+        const service = new SwitzerlandCorporateTaxServiceImpl(input, switzerlandRules);
+        const result = service.calculate();
+        expect(result.corporateTax).toBe(85000);
+    });
+
+    it('calculates effective tax rate as percentage', () => {
+        const input: Input = { taxableIncome: 1000000 };
+        const service = new SwitzerlandCorporateTaxServiceImpl(input, switzerlandRules);
+        const result = service.calculate();
+        expect(result.effectiveTaxRate).toBe(8.5);
+    });
+
+    it('returns one breakdown entry for flat rate calculation', () => {
+        const input: Input = { taxableIncome: 100000 };
+        const service = new SwitzerlandCorporateTaxServiceImpl(input, switzerlandRules);
+        const result = service.calculate();
+        expect(result.breakdowns).toHaveLength(1);
+        expect(result.breakdowns[0].rate).toBe(0.085);
+    });
+});

package/test/switzerland-income-tax.test.ts

@@ -0,0 +1,66 @@
+import { SwitzerlandIncomeTaxServiceImpl } from '../src/income-tax/switzerland/SwitzerlandIncomeTaxServiceImpl';
+import { IncomeTaxRules } from '../src/income-tax/switzerland/domain/types';
+
+const switzerlandRules: IncomeTaxRules = {
+    taxBrackets: [
+        { from: 0, to: 14500, rate: 0 },
+        { from: 14500, to: 31600, rate: 0.0077 },
+        { from: 31600, to: 41400, rate: 0.0088 },
+        { from: 41400, to: 55200, rate: 0.0264 },
+        { from: 55200, to: 72500, rate: 0.0297 },
+        { from: 72500, to: 78100, rate: 0.0594 },
+        { from: 78100, to: 103600, rate: 0.066 },
+        { from: 103600, to: 134600, rate: 0.088 },
+        { from: 134600, to: 176000, rate: 0.11 },
+        { from: 176000, to: 755200, rate: 0.132 },
+        { from: 755200, to: null, rate: 0.115 },
+    ],
+    socialContributions: { rate: 0.053 },
+};
+
+describe('SwitzerlandIncomeTaxServiceImpl', () => {
+    it('returns zero tax for zero income', () => {
+        const service = new SwitzerlandIncomeTaxServiceImpl(0, switzerlandRules);
+        const result = service.calculateNetIncome();
+        expect(result.incomeTax).toBe(0);
+        expect(result.socialContributions).toBe(0);
+        expect(result.effectiveTaxRate).toBe(0);
+    });
+
+    it('returns zero tax for income below first taxable bracket', () => {
+        const service = new SwitzerlandIncomeTaxServiceImpl(10000, switzerlandRules);
+        const result = service.calculateNetIncome();
+        expect(result.incomeTax).toBe(0);
+    });
+
+    it('correctly calculates tax spanning multiple brackets', () => {
+        const service = new SwitzerlandIncomeTaxServiceImpl(50000, switzerlandRules);
+        const result = service.calculateNetIncome();
+        // 0-14500: 0
+        // 14500-31600: 17100 * 0.0077 = 131.67
+        // 31600-41400: 9800 * 0.0088 = 86.24
+        // 41400-50000: 8600 * 0.0264 = 227.04
+        // Total ≈ 444.95
+        expect(result.incomeTax).toBeGreaterThan(0);
+        expect(result.grossIncome).toBe(50000);
+    });
+
+    it('correctly calculates social contributions', () => {
+        const service = new SwitzerlandIncomeTaxServiceImpl(50000, switzerlandRules);
+        const result = service.calculateNetIncome();
+        // 50000 * 0.053 = 2650
+        expect(result.socialContributions).toBeCloseTo(2650, 2);
+    });
+
+    it('net income equals gross income minus total deductions', () => {
+        const service = new SwitzerlandIncomeTaxServiceImpl(100000, switzerlandRules);
+        const result = service.calculateNetIncome();
+        expect(result.netIncome).toBeCloseTo(result.grossIncome - result.totalDeductions, 2);
+    });
+
+    it('total deductions equals income tax plus social contributions', () => {
+        const service = new SwitzerlandIncomeTaxServiceImpl(100000, switzerlandRules);
+        const result = service.calculateNetIncome();
+        expect(result.totalDeductions).toBeCloseTo(result.incomeTax + result.socialContributions, 2);
+    });
+});

package/test/switzerland-mortgage.test.ts

@@ -0,0 +1,70 @@
+import { SwitzerlandMortgageServiceImpl } from '../src/mortgage/switzerland/SwitzerlandMortgageServiceImpl';
+import { MortgageInput, MortgageRules } from '../src/mortgage/switzerland/domain/types';
+
+const switzerlandRules: MortgageRules = {
+    loanConstraints: { maxLtvPercent: 0.80, maxAmortizationYears: 25 },
+    interest: { compounding: 'MONTHLY' },
+    transferTaxRate: 0.0015,
+    notaryFeeRate: 0.005,
+    landRegistryFeeRate: 0.001,
+};
+
+const input: MortgageInput = {
+    propertyPrice: 800000,
+    downPayment: 160000,
+    annualInterestRate: 2.5,
+    amortizationYears: 20,
+};
+
+describe('SwitzerlandMortgageServiceImpl', () => {
+    it('correctly calculates the loan amount', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        expect(result.loanAmount).toBe(640000);
+    });
+
+    it('correctly calculates transfer tax', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        // 800000 * 0.0015 = 1200
+        expect(result.transferTax).toBeCloseTo(1200, 2);
+    });
+
+    it('correctly calculates notary fees', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        // 800000 * 0.005 = 4000
+        expect(result.notaryFees).toBeCloseTo(4000, 2);
+    });
+
+    it('correctly calculates land registry fee', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        // 800000 * 0.001 = 800
+        expect(result.landRegistryFee).toBeCloseTo(800, 2);
+    });
+
+    it('calculates a positive monthly payment', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        expect(result.monthlyPayment).toBeGreaterThan(0);
+    });
+
+    it('total paid is greater than the loan amount', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        expect(result.totalPaid).toBeGreaterThan(result.loanAmount);
+    });
+
+    it('amortization schedule has the correct number of years', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const result = service.calculate(input, switzerlandRules);
+        expect(result.amortizationSchedule).toHaveLength(20);
+    });
+
+    it('throws an error when down payment equals or exceeds property price', () => {
+        const service = new SwitzerlandMortgageServiceImpl();
+        const badInput: MortgageInput = { ...input, downPayment: 800000 };
+        expect(() => service.calculate(badInput, switzerlandRules)).toThrow();
+    });
+});

package/test/uk-inheritance-tax.test.ts

@@ -0,0 +1,72 @@
+import { UKInheritanceTaxServiceImpl } from '../src/inheritance-tax/uk/UKInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/uk/domain/types';
+
+const ukRules: Rules = {
+    nilRateBand: 325000,
+    standardRate: 0.40,
+    charityRate: 0.36,
+    charityThreshold: 10,
+};
+
+describe('UKInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for estate below nil-rate band', () => {
+        const input: Input = { estateValue: 200000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('returns zero tax for estate at nil-rate band', () => {
+        const input: Input = { estateValue: 325000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('applies 40% rate for estate above nil-rate band', () => {
+        const input: Input = { estateValue: 500000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        // (500000 - 325000) * 0.40 = 70000
+        expect(result.taxableEstate).toBe(175000);
+        expect(result.inheritanceTax).toBe(70000);
+    });
+
+    it('applies 36% charity rate when charitable giving >= 10%', () => {
+        const input: Input = { estateValue: 500000, charitableGivingPercent: 10 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        // (500000 - 325000) * 0.36 = 63000
+        expect(result.taxableEstate).toBe(175000);
+        expect(result.inheritanceTax).toBe(63000);
+    });
+
+    it('applies standard rate when charitable giving < 10%', () => {
+        const input: Input = { estateValue: 500000, charitableGivingPercent: 9 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(70000);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 1000000, charitableGivingPercent: 0 };
+        const service = new UKInheritanceTaxServiceImpl(input, ukRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 1000000) * 100);
+    });
+});

package/test/usa-inheritance-tax.test.ts

@@ -0,0 +1,90 @@
+import { USAInheritanceTaxServiceImpl } from '../src/inheritance-tax/usa/USAInheritanceTaxServiceImpl';
+import { Input, Rules } from '../src/inheritance-tax/usa/domain/types';
+
+const usaRules: Rules = {
+    exemption: 13610000,
+    taxBrackets: [
+        { from: 0, to: 10000, rate: 0.18 },
+        { from: 10000, to: 20000, rate: 0.20 },
+        { from: 20000, to: 40000, rate: 0.22 },
+        { from: 40000, to: 60000, rate: 0.24 },
+        { from: 60000, to: 80000, rate: 0.26 },
+        { from: 80000, to: 100000, rate: 0.28 },
+        { from: 100000, to: 150000, rate: 0.30 },
+        { from: 150000, to: 250000, rate: 0.32 },
+        { from: 250000, to: 500000, rate: 0.34 },
+        { from: 500000, to: 750000, rate: 0.36 },
+        { from: 750000, to: 1000000, rate: 0.38 },
+        { from: 1000000, to: null, rate: 0.40 },
+    ],
+};
+
+describe('USAInheritanceTaxServiceImpl', () => {
+    it('returns zero tax for estate below exemption', () => {
+        const input: Input = { estateValue: 10000000 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+        expect(result.breakdowns).toHaveLength(0);
+    });
+
+    it('returns zero tax for estate at exactly the exemption', () => {
+        const input: Input = { estateValue: 13610000 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.taxableEstate).toBe(0);
+    });
+
+    it('correctly calculates tax for estate just above exemption', () => {
+        const input: Input = { estateValue: 13620000 }; // 10000 above exemption
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        // 10000 * 0.18 = 1800
+        expect(result.taxableEstate).toBe(10000);
+        expect(result.inheritanceTax).toBe(1800);
+    });
+
+    it('correctly calculates tax with multiple brackets', () => {
+        const input: Input = { estateValue: 13660000 }; // 50000 above exemption
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        // 10000 * 0.18 = 1800
+        // 10000 * 0.20 = 2000
+        // 20000 * 0.22 = 4400
+        // 10000 * 0.24 = 2400
+        // Total = 10600
+        expect(result.taxableEstate).toBe(50000);
+        expect(result.inheritanceTax).toBe(10600);
+    });
+
+    it('returns zero for zero estate', () => {
+        const input: Input = { estateValue: 0 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+        expect(result.effectiveRate).toBe(0);
+    });
+
+    it('returns zero for negative estate', () => {
+        const input: Input = { estateValue: -100000 };
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.inheritanceTax).toBe(0);
+    });
+
+    it('calculates effective rate correctly', () => {
+        const input: Input = { estateValue: 14610000 }; // 1,000,000 above exemption
+        const service = new USAInheritanceTaxServiceImpl(input, usaRules);
+        const result = service.calculate();
+
+        expect(result.effectiveRate).toBe((result.inheritanceTax / 14610000) * 100);
+    });
+});

package/dist/domain/types.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CalculatorType = void 0;
-var CalculatorType;
-(function (CalculatorType) {
-    CalculatorType["INCOME_TAX"] = "INCOME_TAX";
-    CalculatorType["MORTGAGE"] = "MORTGAGE";
-    CalculatorType["LOAN"] = "LOAN";
-})(CalculatorType || (exports.CalculatorType = CalculatorType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZG9tYWluL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLElBQVksY0FJWDtBQUpELFdBQVksY0FBYztJQUN0QiwyQ0FBeUIsQ0FBQTtJQUN6Qix1Q0FBcUIsQ0FBQTtJQUNyQiwrQkFBYSxDQUFBO0FBQ2pCLENBQUMsRUFKVyxjQUFjLDhCQUFkLGNBQWMsUUFJekIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBDYWxjdWxhdG9yVHlwZSB7XG4gICAgSU5DT01FX1RBWCA9ICdJTkNPTUVfVEFYJyxcbiAgICBNT1JUR0FHRSA9ICdNT1JUR0FHRScsXG4gICAgTE9BTiA9ICdMT0FOJ1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJ1bGVNZXRhIHtcbiAgICBpZDogc3RyaW5nO1xuICAgIGNvdW50cnk6IHN0cmluZztcbiAgICByZWdpb246IHN0cmluZztcbiAgICBjYWxjdWxhdG9yOiBDYWxjdWxhdG9yVHlwZTtcbiAgICB2ZXJzaW9uOiBzdHJpbmc7XG4gICAgZWZmZWN0aXZlZnJvbTogc3RyaW5nO1xuICAgIGVmZmVjdGl2ZXRvOiBzdHJpbmcgfCBudWxsO1xuICAgIHNvdXJjZT86IFJ1bGVTb3VyY2VbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSdWxlU291cmNlIHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgdXJsOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUnVsZUlucHV0IHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgdHlwZTogJ251bWJlcicgfCAnc2VsZWN0JyB8ICd0ZXh0JztcbiAgICByZXF1aXJlZDogYm9vbGVhbjtcbiAgICB1bml0Pzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJ1bGVPdXRwdXQge1xuICAgIG5hbWU6IHN0cmluZztcbiAgICB0eXBlOiAnbnVtYmVyJyB8ICdzdHJpbmcnO1xuICAgIHVuaXQ/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGF4QnJhY2tldCB7XG4gICAgZnJvbTogbnVtYmVyO1xuICAgIHRvOiBudW1iZXIgfCBudWxsO1xuICAgIHJhdGU6IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBJbmNvbWVUYXhDYWxjdWxhdG9yU2NoZW1hPFQ+IHtcbiAgICBtZXRhOiBSdWxlTWV0YTtcbiAgICBpbnB1dHM6IFJ1bGVJbnB1dFtdO1xuICAgIG91dHB1dHM6IFJ1bGVPdXRwdXRbXTtcbiAgICBydWxlczogVDtcbn0iXX0=

package/dist/types/domain/types.d.ts

@@ -1,41 +0,0 @@
-export declare enum CalculatorType {
-    INCOME_TAX = "INCOME_TAX",
-    MORTGAGE = "MORTGAGE",
-    LOAN = "LOAN"
-}
-export interface RuleMeta {
-    id: string;
-    country: string;
-    region: string;
-    calculator: CalculatorType;
-    version: string;
-    effectivefrom: string;
-    effectiveto: string | null;
-    source?: RuleSource[];
-}
-export interface RuleSource {
-    name: string;
-    url: string;
-}
-export interface RuleInput {
-    name: string;
-    type: 'number' | 'select' | 'text';
-    required: boolean;
-    unit?: string;
-}
-export interface RuleOutput {
-    name: string;
-    type: 'number' | 'string';
-    unit?: string;
-}
-export interface TaxBracket {
-    from: number;
-    to: number | null;
-    rate: number;
-}
-export interface IncomeTaxCalculatorSchema<T> {
-    meta: RuleMeta;
-    inputs: RuleInput[];
-    outputs: RuleOutput[];
-    rules: T;
-}