@classytic/stage 0.2.0 → 0.4.0

package/dist/finance/accounting/partnership.mjs

@@ -0,0 +1,152 @@
+import { DEFAULT_ACCOUNTING_POLICY, fromMinor, toMinor } from "./precision.mjs";
+
+//#region src/finance/accounting/partnership.ts
+function solvePartnershipAppropriation(agreement, partners, policy = DEFAULT_ACCOUNTING_POLICY) {
+	const diagnostics = [];
+	if ([
+		agreement.profit,
+		agreement.interestOnCapitalPct,
+		agreement.interestOnDrawingsPct,
+		...partners.flatMap((partner) => [
+			partner.capital,
+			partner.drawings,
+			partner.salary,
+			partner.share,
+			partner.openingCurrentBalance ?? 0
+		])
+	].some((value) => !Number.isFinite(value) || value < 0)) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "Partnership amounts, rates and share units must be finite non-negative values."
+	});
+	if (partners.length < 2) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "A partnership requires at least two partners."
+	});
+	if (partners.some((partner) => partner.share <= 0)) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "Every partner needs a positive profit-sharing unit."
+	});
+	if (new Set(partners.map((partner) => partner.id)).size !== partners.length) diagnostics.push({
+		code: "invalid-adjustment",
+		severity: "error",
+		message: "Partner ids must be unique."
+	});
+	const empty = {
+		totalInterestOnCapital: 0,
+		totalSalaries: 0,
+		totalInterestOnDrawings: 0,
+		residualProfit: 0,
+		partners: [],
+		spread: 0,
+		appropriatesExactly: false,
+		diagnostics,
+		trace: []
+	};
+	if (diagnostics.length > 0) return empty;
+	const m = (value) => toMinor(value, policy);
+	const out = (value) => fromMinor(value, policy);
+	const interestCapital = partners.map((partner) => Math.round(m(partner.capital) * agreement.interestOnCapitalPct / 100));
+	const interestDrawings = partners.map((partner) => Math.round(m(partner.drawings) * agreement.interestOnDrawingsPct / 100));
+	const salaries = partners.map((partner) => m(partner.salary));
+	const totalInterestOnCapital = interestCapital.reduce((sum, value) => sum + value, 0);
+	const totalInterestOnDrawings = interestDrawings.reduce((sum, value) => sum + value, 0);
+	const totalSalaries = salaries.reduce((sum, value) => sum + value, 0);
+	const residual = m(agreement.profit) - totalInterestOnCapital - totalSalaries + totalInterestOnDrawings;
+	const totalUnits = partners.reduce((sum, partner) => sum + partner.share, 0);
+	let allocated = 0;
+	const residualShares = partners.map((partner, index) => {
+		const share = index === partners.length - 1 ? residual - allocated : Math.round(residual * partner.share / totalUnits);
+		allocated += share;
+		return share;
+	});
+	const solvedPartners = partners.map((partner, index) => {
+		const ioc = interestCapital[index], iod = interestDrawings[index], salary = salaries[index], share = residualShares[index];
+		const opening = m(partner.openingCurrentBalance ?? 0) * (partner.openingCurrentSide === "debit" ? -1 : 1);
+		const credits = ioc + salary + share;
+		const debits = m(partner.drawings) + iod;
+		const closing = opening + credits - debits;
+		const movements = [
+			{
+				label: "Opening balance",
+				side: partner.openingCurrentSide ?? "credit",
+				amount: out(Math.abs(opening))
+			},
+			{
+				label: "Interest on capital",
+				side: "credit",
+				amount: out(ioc)
+			},
+			{
+				label: "Partner salary",
+				side: "credit",
+				amount: out(salary)
+			},
+			{
+				label: "Share of residual profit",
+				side: "credit",
+				amount: out(share)
+			},
+			{
+				label: "Drawings",
+				side: "debit",
+				amount: partner.drawings
+			},
+			{
+				label: "Interest on drawings",
+				side: "debit",
+				amount: out(iod)
+			}
+		].filter((movement) => movement.amount !== 0);
+		return {
+			id: partner.id,
+			name: partner.name,
+			interestOnCapital: out(ioc),
+			salary: out(salary),
+			interestOnDrawings: out(iod),
+			shareOfResidual: out(share),
+			totalAppropriation: out(ioc + salary + share - iod),
+			currentAccountMovements: movements,
+			closingCurrentBalance: out(Math.abs(closing)),
+			closingCurrentSide: closing === 0 ? "zero" : closing > 0 ? "credit" : "debit"
+		};
+	});
+	const totals = solvedPartners.map((partner) => m(partner.totalAppropriation));
+	const appropriated = totals.reduce((sum, value) => sum + value, 0);
+	const spread = Math.max(...totals) - Math.min(...totals);
+	return {
+		totalInterestOnCapital: out(totalInterestOnCapital),
+		totalSalaries: out(totalSalaries),
+		totalInterestOnDrawings: out(totalInterestOnDrawings),
+		residualProfit: out(residual),
+		partners: solvedPartners,
+		spread: out(spread),
+		appropriatesExactly: appropriated === m(agreement.profit),
+		diagnostics,
+		trace: [{
+			id: "partnership:residual",
+			kind: "derive",
+			rule: "Residual profit = profit − interest on capital − salaries + interest on drawings.",
+			working: `${agreement.profit} − ${out(totalInterestOnCapital)} − ${out(totalSalaries)} + ${out(totalInterestOnDrawings)}`,
+			result: out(residual)
+		}, {
+			id: "partnership:allocation",
+			kind: "check",
+			rule: "Appropriation redistributes the profit; it does not create or remove profit.",
+			working: `${out(appropriated)} compared with ${agreement.profit}`,
+			result: appropriated === m(agreement.profit)
+		}]
+	};
+}
+function salaryForEqualPartnershipShares(agreement, partners, policy = DEFAULT_ACCOUNTING_POLICY) {
+	if (partners.length !== 2 || partners[0].share !== partners[1].share) return null;
+	const own = (partner) => partner.capital * agreement.interestOnCapitalPct / 100 - partner.drawings * agreement.interestOnDrawingsPct / 100;
+	const salaried = partners[1].salary > 0 || partners[0].salary === 0 ? partners[1] : partners[0];
+	const other = salaried === partners[1] ? partners[0] : partners[1];
+	return fromMinor(toMinor(Math.max(0, own(other) - own(salaried)), policy), policy);
+}
+
+//#endregion
+export { salaryForEqualPartnershipShares, solvePartnershipAppropriation };

package/dist/finance/accounting/period-case.d.mts

@@ -0,0 +1,6 @@
+import { AccountingPolicy, SoleTraderPeriodCase, SoleTraderPeriodResult } from "./types.mjs";
+
+//#region src/finance/accounting/period-case.d.ts
+declare function solveSoleTraderPeriod(period: SoleTraderPeriodCase, policy?: AccountingPolicy): SoleTraderPeriodResult;
+//#endregion
+export { solveSoleTraderPeriod };

package/dist/finance/accounting/period-case.mjs

@@ -0,0 +1,71 @@
+import { DEFAULT_ACCOUNTING_POLICY, fromMinor, toMinor } from "./precision.mjs";
+import { solveJournal } from "./solve.mjs";
+import { produceAdjustment } from "./adjustments.mjs";
+import { solveSoleTraderStatements } from "./statements.mjs";
+
+//#region src/finance/accounting/period-case.ts
+function sum(ledger, policy, predicate) {
+	return fromMinor(ledger.filter(predicate).reduce((total, account) => total + toMinor(account.normalBalance, policy), 0), policy);
+}
+function solveSoleTraderPeriod(period, policy = DEFAULT_ACCOUNTING_POLICY) {
+	const unadjusted = solveJournal({
+		accounts: period.accounts,
+		entries: period.unadjustedEntries,
+		policy
+	});
+	const adjustmentResults = period.adjustments.map((fact) => produceAdjustment(fact, policy));
+	const adjustmentDiagnostics = adjustmentResults.flatMap((result) => result.diagnostics);
+	const adjustmentTrace = adjustmentResults.flatMap((result) => result.trace);
+	const adjusted = solveJournal({
+		accounts: period.accounts,
+		entries: [...period.unadjustedEntries, ...adjustmentResults.flatMap((result) => result.entries)],
+		policy,
+		initialDiagnostics: adjustmentDiagnostics,
+		trace: adjustmentTrace
+	});
+	const ledger = adjusted.ledger;
+	const revenue = sum(ledger, policy, (account) => account.role === "revenue");
+	const costOfSales = sum(ledger, policy, (account) => account.role === "cost-of-sales");
+	const expenses = sum(ledger, policy, (account) => account.category === "Expense" && account.role !== "cost-of-sales");
+	const nonCurrentAssets = sum(ledger, policy, (account) => account.role === "equipment");
+	const inventory = sum(ledger, policy, (account) => account.role === "inventory");
+	const cash = sum(ledger, policy, (account) => account.role === "cash" || account.role === "bank");
+	const otherCurrentAssets = sum(ledger, policy, (account) => account.category === "Asset" && account.role !== "equipment" && account.role !== "inventory" && account.role !== "cash" && account.role !== "bank");
+	const openingCapital = sum(ledger, policy, (account) => account.role === "capital");
+	const drawings = -sum(ledger, policy, (account) => account.role === "drawings");
+	const loan = sum(ledger, policy, (account) => account.role === "loan");
+	const currentLiabilities = sum(ledger, policy, (account) => account.category === "Liability" && account.role !== "loan");
+	const missingRoles = ["revenue", "capital"].flatMap((role) => !period.accounts.some((account) => account.role === role) ? [{
+		code: "missing-role",
+		severity: "error",
+		message: `The period case requires a non-zero ${role} account role.`
+	}] : []);
+	const statements = solveSoleTraderStatements({
+		revenue,
+		costOfSales,
+		expenses,
+		nonCurrentAssets,
+		inventory,
+		cash,
+		otherCurrentAssets,
+		openingCapital,
+		drawings,
+		loan,
+		currentLiabilities
+	}, policy);
+	return {
+		unadjusted,
+		adjustmentResults,
+		adjusted,
+		statements,
+		diagnostics: [
+			...adjusted.diagnostics,
+			...missingRoles,
+			...statements.diagnostics
+		],
+		trace: [...adjusted.trace, ...statements.trace]
+	};
+}
+
+//#endregion
+export { solveSoleTraderPeriod };

package/dist/finance/accounting/post.d.mts

@@ -0,0 +1,9 @@
+import { AccountDefinition, AccountingEquation, AccountingPolicy, FinancialStatements, JournalEntry, LedgerAccount, TrialBalance } from "./types.mjs";
+
+//#region src/finance/accounting/post.d.ts
+declare function postLedger(accounts: readonly AccountDefinition[], entries: readonly JournalEntry[], policy: AccountingPolicy): LedgerAccount[];
+declare function deriveTrialBalance(ledger: readonly LedgerAccount[], policy: AccountingPolicy): TrialBalance;
+declare function deriveEquation(ledger: readonly LedgerAccount[], policy: AccountingPolicy): AccountingEquation;
+declare function deriveStatements(equation: AccountingEquation): FinancialStatements;
+//#endregion
+export { deriveEquation, deriveStatements, deriveTrialBalance, postLedger };

package/dist/finance/accounting/post.mjs

@@ -0,0 +1,84 @@
+import { fromMinor, toMinor } from "./precision.mjs";
+import { normalBalance } from "./rules.mjs";
+
+//#region src/finance/accounting/post.ts
+function postLedger(accounts, entries, policy) {
+	return accounts.map((account) => {
+		const postings = [];
+		for (const entry of entries) {
+			const contras = entry.lines.filter((line) => line.accountId !== account.id).map((line) => line.accountId);
+			for (const line of entry.lines.filter((item) => item.accountId === account.id)) postings.push({
+				entryId: entry.id,
+				contraAccountIds: contras,
+				side: line.side,
+				amount: fromMinor(toMinor(line.amount, policy), policy),
+				narration: entry.narration
+			});
+		}
+		const debitMinor = postings.filter((posting) => posting.side === "debit").reduce((sum, posting) => sum + toMinor(posting.amount, policy), 0);
+		const creditMinor = postings.filter((posting) => posting.side === "credit").reduce((sum, posting) => sum + toMinor(posting.amount, policy), 0);
+		const netMinor = debitMinor - creditMinor;
+		const side = netMinor > 0 ? "debit" : netMinor < 0 ? "credit" : "zero";
+		const naturalMinor = netMinor === 0 ? 0 : normalBalance(account.category) === "debit" ? netMinor : -netMinor;
+		return {
+			...account,
+			postings,
+			debitTotal: fromMinor(debitMinor, policy),
+			creditTotal: fromMinor(creditMinor, policy),
+			balance: fromMinor(Math.abs(netMinor), policy),
+			balanceSide: side,
+			normalBalance: fromMinor(naturalMinor, policy)
+		};
+	});
+}
+function deriveTrialBalance(ledger, policy) {
+	const lines = ledger.filter((account) => account.balanceSide !== "zero").map((account) => ({
+		accountId: account.id,
+		name: account.name,
+		debit: account.balanceSide === "debit" ? account.balance : 0,
+		credit: account.balanceSide === "credit" ? account.balance : 0
+	}));
+	const debitMinor = lines.reduce((sum, line) => sum + toMinor(line.debit, policy), 0);
+	const creditMinor = lines.reduce((sum, line) => sum + toMinor(line.credit, policy), 0);
+	return {
+		lines,
+		debitTotal: fromMinor(debitMinor, policy),
+		creditTotal: fromMinor(creditMinor, policy),
+		balances: debitMinor === creditMinor
+	};
+}
+function deriveEquation(ledger, policy) {
+	const total = (category) => ledger.filter((account) => account.category === category).reduce((sum, account) => sum + toMinor(account.normalBalance, policy), 0);
+	const assetsMinor = total("Asset"), liabilitiesMinor = total("Liability"), equityBaseMinor = total("Equity"), incomeMinor = total("Income"), expensesMinor = total("Expense");
+	const profitMinor = incomeMinor - expensesMinor, equityMinor = equityBaseMinor + profitMinor;
+	return {
+		assets: fromMinor(assetsMinor, policy),
+		liabilities: fromMinor(liabilitiesMinor, policy),
+		contributedEquity: fromMinor(equityBaseMinor, policy),
+		income: fromMinor(incomeMinor, policy),
+		expenses: fromMinor(expensesMinor, policy),
+		profit: fromMinor(profitMinor, policy),
+		equity: fromMinor(equityMinor, policy),
+		left: fromMinor(assetsMinor, policy),
+		right: fromMinor(liabilitiesMinor + equityMinor, policy),
+		balances: assetsMinor === liabilitiesMinor + equityMinor
+	};
+}
+function deriveStatements(equation) {
+	return {
+		incomeStatement: {
+			income: equation.income,
+			expenses: equation.expenses,
+			profit: equation.profit
+		},
+		statementOfFinancialPosition: {
+			assets: equation.assets,
+			liabilities: equation.liabilities,
+			equity: equation.equity,
+			balances: equation.balances
+		}
+	};
+}
+
+//#endregion
+export { deriveEquation, deriveStatements, deriveTrialBalance, postLedger };

package/dist/finance/accounting/precision.d.mts

@@ -0,0 +1,9 @@
+import { AccountingPolicy } from "./types.mjs";
+
+//#region src/finance/accounting/precision.d.ts
+declare const DEFAULT_ACCOUNTING_POLICY: AccountingPolicy;
+declare function amountScale(policy?: AccountingPolicy): number;
+declare function toMinor(amount: number, policy?: AccountingPolicy): number;
+declare function fromMinor(amount: number, policy?: AccountingPolicy): number;
+//#endregion
+export { DEFAULT_ACCOUNTING_POLICY, amountScale, fromMinor, toMinor };

package/dist/finance/accounting/precision.mjs

@@ -0,0 +1,15 @@
+//#region src/finance/accounting/precision.ts
+const DEFAULT_ACCOUNTING_POLICY = { decimalPlaces: 2 };
+function amountScale(policy = DEFAULT_ACCOUNTING_POLICY) {
+	if (!Number.isInteger(policy.decimalPlaces) || policy.decimalPlaces < 0 || policy.decimalPlaces > 6) throw new Error("decimalPlaces must be an integer from 0 to 6");
+	return 10 ** policy.decimalPlaces;
+}
+function toMinor(amount, policy = DEFAULT_ACCOUNTING_POLICY) {
+	return Math.round(amount * amountScale(policy));
+}
+function fromMinor(amount, policy = DEFAULT_ACCOUNTING_POLICY) {
+	return amount / amountScale(policy);
+}
+
+//#endregion
+export { DEFAULT_ACCOUNTING_POLICY, amountScale, fromMinor, toMinor };

package/dist/finance/accounting/rules.d.mts

@@ -0,0 +1,21 @@
+import { AccountCategory, PostingSide } from "./types.mjs";
+
+//#region src/finance/accounting/rules.d.ts
+declare function normalBalance(category: AccountCategory): PostingSide;
+declare function statementOf(category: AccountCategory): 'financial-position' | 'income';
+declare function changeSide(category: AccountCategory, change: 'increase' | 'decrease'): PostingSide;
+declare function totalsBalance(lines: ReadonlyArray<{
+  debit?: number;
+  credit?: number;
+}>, tolerance?: number): boolean;
+declare function deriveNaturalEquation(accounts: ReadonlyArray<{
+  id: string;
+  category: AccountCategory;
+}>, balanceOf: (id: string) => number): {
+  assets: number;
+  liabilities: number;
+  equity: number;
+  profit: number;
+};
+//#endregion
+export { changeSide, deriveNaturalEquation, normalBalance, statementOf, totalsBalance };

package/dist/finance/accounting/rules.mjs

@@ -0,0 +1,37 @@
+//#region src/finance/accounting/rules.ts
+function normalBalance(category) {
+	return category === "Asset" || category === "Expense" ? "debit" : "credit";
+}
+function statementOf(category) {
+	return category === "Income" || category === "Expense" ? "income" : "financial-position";
+}
+function changeSide(category, change) {
+	const normal = normalBalance(category);
+	if (change === "increase") return normal;
+	return normal === "debit" ? "credit" : "debit";
+}
+function totalsBalance(lines, tolerance = .005) {
+	const debit = lines.reduce((sum, line) => sum + (line.debit ?? 0), 0);
+	const credit = lines.reduce((sum, line) => sum + (line.credit ?? 0), 0);
+	return Math.abs(debit - credit) < tolerance;
+}
+function deriveNaturalEquation(accounts, balanceOf) {
+	const totals = {
+		Asset: 0,
+		Liability: 0,
+		Equity: 0,
+		Income: 0,
+		Expense: 0
+	};
+	for (const account of accounts) totals[account.category] += balanceOf(account.id);
+	const profit = totals.Income - totals.Expense;
+	return {
+		assets: totals.Asset,
+		liabilities: totals.Liability,
+		equity: totals.Equity + profit,
+		profit
+	};
+}
+
+//#endregion
+export { changeSide, deriveNaturalEquation, normalBalance, statementOf, totalsBalance };

package/dist/finance/accounting/solve.d.mts

@@ -0,0 +1,28 @@
+import { AccountDefinition, AccountingDiagnostic, AccountingPolicy, AccountingSolution, BusinessEvent, ExplanationStep, JournalEntry } from "./types.mjs";
+
+//#region src/finance/accounting/solve.d.ts
+interface SolveJournalOptions {
+  accounts: readonly AccountDefinition[];
+  entries: readonly JournalEntry[];
+  policy?: AccountingPolicy;
+  trace?: readonly ExplanationStep[];
+  initialDiagnostics?: readonly AccountingDiagnostic[];
+}
+declare function solveJournal({
+  accounts,
+  entries,
+  policy,
+  trace: initialTrace,
+  initialDiagnostics
+}: SolveJournalOptions): AccountingSolution;
+declare function solveBusinessProblem({
+  accounts,
+  events,
+  policy
+}: {
+  accounts: readonly AccountDefinition[];
+  events: readonly BusinessEvent[];
+  policy?: AccountingPolicy;
+}): AccountingSolution;
+//#endregion
+export { SolveJournalOptions, solveBusinessProblem, solveJournal };

package/dist/finance/accounting/solve.mjs

@@ -0,0 +1,92 @@
+import { journalizeBusinessEvents } from "./journalize.mjs";
+import { DEFAULT_ACCOUNTING_POLICY } from "./precision.mjs";
+import { deriveEquation, deriveStatements, deriveTrialBalance, postLedger } from "./post.mjs";
+import { validateChart, validateJournalEntry } from "./validate.mjs";
+
+//#region src/finance/accounting/solve.ts
+function solveJournal({ accounts, entries, policy = DEFAULT_ACCOUNTING_POLICY, trace: initialTrace = [], initialDiagnostics = [] }) {
+	const chartDiagnostics = validateChart(accounts);
+	const diagnostics = [...initialDiagnostics, ...chartDiagnostics];
+	const trace = [...initialTrace];
+	const acceptedEntries = [], rejectedEntries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const entryDiagnostics = validateJournalEntry(entry, accounts, policy);
+		if (chartDiagnostics.some((diagnostic) => diagnostic.severity === "error")) entryDiagnostics.push({
+			code: "duplicate-account",
+			severity: "error",
+			entryId: entry.id,
+			message: "The chart of accounts is invalid, so no journal can be posted."
+		});
+		if (seen.has(entry.id)) entryDiagnostics.push({
+			code: "duplicate-entry",
+			severity: "error",
+			entryId: entry.id,
+			message: `Entry ${entry.id} is declared more than once.`
+		});
+		seen.add(entry.id);
+		diagnostics.push(...entryDiagnostics);
+		const accepted = entryDiagnostics.every((diagnostic) => diagnostic.severity !== "error");
+		(accepted ? acceptedEntries : rejectedEntries).push(entry);
+		trace.push({
+			id: `${entry.id}:validate`,
+			kind: "validate",
+			rule: "A postable journal needs known accounts, positive amounts and equal debit and credit totals.",
+			working: `${entry.lines.length} line(s) checked`,
+			result: accepted ? "accepted" : "rejected"
+		});
+	}
+	const ledger = postLedger(accounts, acceptedEntries, policy);
+	for (const account of ledger.filter((item) => item.postings.length > 0)) trace.push({
+		id: `${account.id}:post`,
+		kind: "post",
+		rule: "Post each journal line to its named ledger account.",
+		working: `${account.debitTotal} debit − ${account.creditTotal} credit`,
+		result: `${account.balance} ${account.balanceSide}`
+	});
+	const trialBalance = deriveTrialBalance(ledger, policy);
+	const equation = deriveEquation(ledger, policy);
+	const statements = deriveStatements(equation);
+	trace.push({
+		id: "trial-balance",
+		kind: "check",
+		rule: "A trial balance compares closing debit and credit balances.",
+		working: `${trialBalance.debitTotal} = ${trialBalance.creditTotal}`,
+		result: trialBalance.balances
+	}, {
+		id: "profit",
+		kind: "derive",
+		rule: "Profit = income − expenses.",
+		working: `${equation.income} − ${equation.expenses}`,
+		result: equation.profit
+	}, {
+		id: "equation",
+		kind: "check",
+		rule: "Assets = liabilities + equity, including current-period profit.",
+		working: `${equation.left} = ${equation.liabilities} + ${equation.equity}`,
+		result: equation.balances
+	});
+	return {
+		acceptedEntries,
+		rejectedEntries,
+		diagnostics,
+		ledger,
+		trialBalance,
+		equation,
+		statements,
+		trace
+	};
+}
+function solveBusinessProblem({ accounts, events, policy = DEFAULT_ACCOUNTING_POLICY }) {
+	const journalized = journalizeBusinessEvents(events, accounts);
+	return solveJournal({
+		accounts,
+		entries: journalized.entries,
+		policy,
+		trace: journalized.trace,
+		initialDiagnostics: journalized.diagnostics
+	});
+}
+
+//#endregion
+export { solveBusinessProblem, solveJournal };

package/dist/finance/accounting/statements.d.mts

@@ -0,0 +1,7 @@
+import { AccountingPolicy, SoleTraderStatementFacts, SoleTraderStatementResult } from "./types.mjs";
+
+//#region src/finance/accounting/statements.d.ts
+declare function solveSoleTraderStatements(facts: SoleTraderStatementFacts, policy?: AccountingPolicy): SoleTraderStatementResult;
+declare function solveCashSettledSoleTraderScenario(base: SoleTraderStatementFacts, trading: Pick<SoleTraderStatementFacts, 'revenue' | 'costOfSales' | 'expenses'>, policy?: AccountingPolicy): SoleTraderStatementResult;
+//#endregion
+export { solveCashSettledSoleTraderScenario, solveSoleTraderStatements };