tallyd 0.0.0-stage → 0.1.0

package/dist/group/acquisition.js

@@ -0,0 +1,416 @@
+/**
+ * What was paid, what was bought, and what belongs to everybody else.
+ *
+ * A combined trial balance still carries the parent's investment in each
+ * subsidiary as an asset *and* the subsidiary's own share capital as equity,
+ * which is the same money on the page twice: the investment is a claim on
+ * exactly the net assets that are already there line by line. Both come out,
+ * and what is left over is goodwill — the part of the price that bought
+ * something the subsidiary's balance sheet does not carry.
+ *
+ *     goodwill = consideration + non-controlling interest at acquisition
+ *                - the net assets acquired
+ *
+ * The non-controlling interest belongs in that sum because goodwill is a
+ * measure of what the whole company was worth against what its identifiable
+ * net assets were worth, and the group only bought part of it. How the
+ * non-controlling interest is measured is a choice the group makes per
+ * acquisition and it changes the goodwill figure:
+ *
+ * - **Proportionate**: its share of the identifiable net assets. Goodwill is
+ *   then only the group's own, and the balance sheet carries none of the
+ *   goodwill attributable to the outside shareholders.
+ * - **Fair value**: what the outside stake was actually worth on the day,
+ *   which is usually more, and the difference is the goodwill attributable to
+ *   the non-controlling interest.
+ *
+ * A price below the net assets acquired is a bargain purchase, and the excess
+ * is a gain in the income statement rather than a negative asset. Negative
+ * goodwill sitting in the balance sheet would be asserting that the group owns
+ * something worth less than nothing.
+ *
+ * Afterwards, the two sides share what the subsidiary earns in the ratio of
+ * their interests. The non-controlling interest's claim at any date is its
+ * share of the net assets then, plus whatever goodwill was attributed to it at
+ * acquisition — a formulation that needs no roll-forward and cannot drift.
+ *
+ * On an indirect holding this uses the direct method: a company held 75% by a
+ * subsidiary that is itself held 80% has a 40% non-controlling interest from
+ * the group's point of view, and its goodwill is measured against the price
+ * the subsidiary paid. The alternative treatment, which scales the cost of the
+ * investment by the group's interest in the buyer, is a known gap.
+ *
+ * ## Which currency the arithmetic happens in
+ *
+ * All of it happens in the currency the acquired company keeps its books in,
+ * and the answer is then translated into the group's. That ordering is not a
+ * matter of taste. Goodwill on a foreign operation is an asset *of that
+ * operation*: what the extra money bought — a name, a position, people who
+ * stay — is a thing in that country, priced in that currency, and the group
+ * owning it does not move it. So the consideration comes the other way for the
+ * purposes of this sum, into the subsidiary's currency at the rate on the day,
+ * and the net assets read from its own books need no translating because they
+ * are already there.
+ *
+ * Doing it the other way round — translating each input into the group's
+ * currency and taking the residual there — gives a figure that cannot be
+ * retranslated afterwards, because there is no functional-currency amount left
+ * to retranslate, and one that carries three roundings instead of one: each
+ * input is rounded on its way across and goodwill is defined as the difference
+ * between them, so the error lands in the one figure with nothing to absorb it.
+ *
+ * A group reporting in the currency its subsidiary already keeps is untouched
+ * by any of this: no rate is looked up and nothing moves.
+ */
+import { Money } from "../money/money.js";
+import { compareDates, date as parseDate, } from "../ledger/date.js";
+import { trialBalance } from "../ledger/trialBalance.js";
+import { Interest } from "./interest.js";
+import { GroupError } from "./structure.js";
+import { GROUP_ACCOUNTS } from "./accounts.js";
+/**
+ * The net assets of an entity on a date, read from its own books.
+ *
+ * Assets less liabilities, which in the signed convention is simply the sum of
+ * the asset and liability rows: the trial balance's other rows are the claims
+ * on them.
+ */
+export function netAssets(ledger, asAt, currency) {
+    const tb = trialBalance(ledger, { currency, asAt, includeZero: true });
+    return tb.rows
+        .filter((row) => row.type === "asset" || row.type === "liability")
+        .reduce((running, row) => running.plus(row.signed), Money.zero(currency));
+}
+/**
+ * One amount into another currency at a given day's rate.
+ *
+ * `why` finishes the sentence "there is no rate on <date>" in the error, so a
+ * caller who has not supplied a quote is told which figure needed it and which
+ * way it was going rather than being handed a bare lookup failure.
+ */
+function convertOn(amount, into, options, on, what) {
+    if (amount.currency.code === into.code)
+        return amount;
+    try {
+        return options.rates
+            .lookup(amount.currency, into, on)
+            .rate.convert(amount, options.rounding ?? "half-even");
+    }
+    catch (error) {
+        throw new GroupError(`${what} is in ${amount.currency.code} and has to be stated in ${into.code}, ` +
+            `but there is no rate on ${on}: ${error.message}`);
+    }
+}
+/**
+ * A functional-currency measurement and its presentation-currency statement.
+ *
+ * The translation happens here and only here, so every figure on an
+ * `Acquisition` is one rounding away from the amount it was measured as.
+ */
+function measured(functional, options, on, what) {
+    return Object.freeze({
+        functional,
+        presentation: convertOn(functional, options.presentation, options, on, what),
+    });
+}
+/**
+ * Work out goodwill and the non-controlling interest at acquisition.
+ *
+ * Everything is measured on the day control was obtained, in the acquired
+ * company's own currency, and translated at that day's rate. The date is the
+ * acquisition date because that is when the bargain was struck: a rate that
+ * moved afterwards changes what the group's investment is worth, not what it
+ * paid. The currency is the subsidiary's because goodwill is an asset of the
+ * subsidiary; see the note at the top of this file.
+ */
+export function acquisitionOf(group, ledgers, input, options) {
+    const entity = group.get(input.entity);
+    if (entity.code === group.parent) {
+        throw new GroupError(`${entity.code} is the parent company; nobody acquired it`);
+    }
+    if (!entity.controlled) {
+        throw new GroupError(`${entity.code} is not consolidated, so there is no acquisition to account for. ` +
+            `It is held ${entity.effective.toPercentString(4)} and carried at cost.`);
+    }
+    const acquiredText = input.acquired ?? entity.acquired;
+    if (acquiredText === null || acquiredText === undefined) {
+        throw new GroupError(`${entity.code} needs the date control was obtained: without it there is no way ` +
+            `to tell pre-acquisition reserves from post-acquisition ones.`);
+    }
+    const acquired = parseDate(acquiredText);
+    const measurement = input.nciMeasurement ?? "proportionate";
+    const rounding = options.rounding ?? "half-even";
+    const functional = entity.currency;
+    const zero = Money.zero(functional);
+    // Everything below is in the acquired company's own currency.
+    const consideration = convertOn(input.consideration, functional, options, acquired, `The consideration for ${entity.code}`);
+    let netAssetsAcquired;
+    let netAssetsSupplied;
+    if (input.netAssetsAtAcquisition !== undefined) {
+        netAssetsAcquired = convertOn(input.netAssetsAtAcquisition, functional, options, acquired, `The net assets acquired with ${entity.code}`);
+        netAssetsSupplied = true;
+    }
+    else {
+        const ledger = ledgers instanceof Map
+            ? ledgers.get(entity.code)
+            : ledgers[entity.code];
+        if (ledger === undefined) {
+            throw new GroupError(`No books for ${entity.code}, so its net assets cannot be read`);
+        }
+        netAssetsAcquired = netAssets(ledger, acquired, functional);
+        netAssetsSupplied = false;
+    }
+    const nci = entity.nonControlling;
+    const nciShareOfNetAssets = nci.share(netAssetsAcquired, rounding);
+    let nciAtAcquisition;
+    if (measurement === "fair-value") {
+        if (input.nciFairValue === undefined) {
+            throw new GroupError(`${entity.code} measures its non-controlling interest at fair value, which is a ` +
+                `figure only the group has: supply nciFairValue or use the proportionate method.`);
+        }
+        nciAtAcquisition = convertOn(input.nciFairValue, functional, options, acquired, `The fair value of the non-controlling interest in ${entity.code}`);
+    }
+    else {
+        if (input.nciFairValue !== undefined) {
+            throw new GroupError(`${entity.code} gives a fair value for its non-controlling interest but measures it ` +
+                `proportionately, so the figure would be ignored. Say which is meant.`);
+        }
+        nciAtAcquisition = nciShareOfNetAssets;
+    }
+    const excess = consideration.plus(nciAtAcquisition).minus(netAssetsAcquired);
+    const goodwill = excess.isNegative ? zero : excess;
+    const bargainGain = excess.isNegative ? excess.negated() : zero;
+    const nciGoodwill = nciAtAcquisition.minus(nciShareOfNetAssets);
+    const considerationIn = measured(consideration, options, acquired, `The consideration for ${entity.code}`);
+    const netAssetsAcquiredIn = measured(netAssetsAcquired, options, acquired, `The net assets acquired with ${entity.code}`);
+    const nciAtAcquisitionIn = measured(nciAtAcquisition, options, acquired, `The non-controlling interest in ${entity.code} at acquisition`);
+    const goodwillIn = measured(goodwill, options, acquired, `Goodwill on ${entity.code}`);
+    const bargainGainIn = measured(bargainGain, options, acquired, `The bargain purchase gain on ${entity.code}`);
+    const nciGoodwillIn = measured(nciGoodwill, options, acquired, `The outside stake's goodwill on ${entity.code}`);
+    return Object.freeze({
+        entity: entity.code,
+        acquired,
+        groupInterest: entity.effective,
+        nonControllingInterest: nci,
+        measurement,
+        functional,
+        presentation: options.presentation,
+        consideration: considerationIn.presentation,
+        considerationIn,
+        netAssetsAcquired: netAssetsAcquiredIn.presentation,
+        netAssetsAcquiredIn,
+        netAssetsSupplied,
+        nciAtAcquisition: nciAtAcquisitionIn.presentation,
+        nciAtAcquisitionIn,
+        goodwill: goodwillIn.presentation,
+        goodwillIn,
+        bargainGain: bargainGainIn.presentation,
+        bargainGainIn,
+        nciGoodwill: nciGoodwillIn.presentation,
+        nciGoodwillIn,
+        investmentAccount: input.investmentAccount ?? GROUP_ACCOUNTS.investment,
+    });
+}
+export function goodwillAt(acquisition, options, on) {
+    const rounding = options.rounding ?? "half-even";
+    const grossFunctional = acquisition.goodwillIn.functional;
+    const grossNciFunctional = acquisition.nciGoodwillIn.functional;
+    const sameCurrency = acquisition.functional.code === acquisition.presentation.code;
+    const zeroFunctional = Money.zero(acquisition.functional);
+    const closingRate = (when, what) => {
+        try {
+            return options.rates.lookup(acquisition.functional, acquisition.presentation, when).rate;
+        }
+        catch (error) {
+            throw new GroupError(`${what} on ${acquisition.entity} is ${acquisition.functional.code} and has to be ` +
+                `stated in ${acquisition.presentation.code}, but there is no rate ` +
+                `on ${when}: ${error.message}`);
+        }
+    };
+    // The impairment comes off the measurement before any rate touches it: what
+    // is retranslated is what is left. Events after the carrying date are not
+    // yet news, and events inside the reporting period are this period's charge
+    // as well as part of the accumulated total.
+    const events = [...(options.impairments ?? [])]
+        .map((declared) => {
+        if (declared.entity !== acquisition.entity) {
+            throw new GroupError(`An impairment of goodwill on ${declared.entity} was given to ${acquisition.entity}`);
+        }
+        const when = parseDate(declared.on);
+        if (compareDates(when, acquisition.acquired) < 0) {
+            throw new GroupError(`Goodwill on ${acquisition.entity} is written off on ${when}, before it arose on ` +
+                `${acquisition.acquired}. There was nothing there to write off.`);
+        }
+        const amount = convertOn(declared.amount, acquisition.functional, {
+            rates: options.rates,
+            presentation: acquisition.presentation,
+            ...(options.rounding === undefined ? {} : { rounding: options.rounding }),
+        }, when, `The impairment of goodwill on ${acquisition.entity}`);
+        if (amount.isNegative) {
+            throw new GroupError(`Goodwill on ${acquisition.entity} is written back up by ${amount.negated()} on ` +
+                `${when}. An impairment once recognised stays recognised.`);
+        }
+        return { when, amount };
+    })
+        .filter((event) => compareDates(event.when, on) <= 0)
+        .sort((a, b) => compareDates(a.when, b.when));
+    const inPeriod = (when) => options.period === undefined ||
+        (compareDates(when, options.period.from) >= 0 && compareDates(when, options.period.to) <= 0);
+    let impairedFunctional = zeroFunctional;
+    let chargedFunctional = zeroFunctional;
+    let nciImpairedFunctional = zeroFunctional;
+    let nciChargedFunctional = zeroFunctional;
+    // Each event's loss takes the rate on its own day, so the sum of them is
+    // what the income statement has carried over the asset's life and the
+    // residual against the closing rate is the rate's doing and nothing else.
+    let recognisedAtTheTime = Money.zero(acquisition.presentation);
+    let nciRecognisedAtTheTime = Money.zero(acquisition.presentation);
+    let chargeLoss = Money.zero(acquisition.presentation);
+    let nciChargeLoss = Money.zero(acquisition.presentation);
+    for (const event of events) {
+        // The stake bears its ownership fraction of the loss, not its share of the
+        // goodwill: a loss of the period is shared the way every result is. Where
+        // the stake was measured proportionately it has no goodwill on the balance
+        // sheet and so no recognised share of a write-down of it.
+        const nciAmount = acquisition.measurement === "fair-value"
+            ? acquisition.nonControllingInterest.share(event.amount, rounding)
+            : zeroFunctional;
+        impairedFunctional = impairedFunctional.plus(event.amount);
+        nciImpairedFunctional = nciImpairedFunctional.plus(nciAmount);
+        if (impairedFunctional.greaterThan(grossFunctional)) {
+            throw new GroupError(`${impairedFunctional} of goodwill is written off ${acquisition.entity} by ${event.when}, ` +
+                `which only has ${grossFunctional}. Goodwill carried at a negative amount is not a ` +
+                `smaller error than the one being corrected.`);
+        }
+        if (nciImpairedFunctional.greaterThan(grossNciFunctional)) {
+            throw new GroupError(`The outside stake's share of the impairments on ${acquisition.entity} reaches ` +
+                `${nciImpairedFunctional} by ${event.when}, more than the ${grossNciFunctional} of ` +
+                `goodwill attributed to it. Writing its claim below what it was given would charge ` +
+                `it for goodwill it never had.`);
+        }
+        const eventRate = sameCurrency ? null : closingRate(event.when, "The impairment of goodwill");
+        const atTheTime = eventRate === null ? event.amount : eventRate.convert(event.amount, rounding);
+        const nciAtTheTime = eventRate === null ? nciAmount : eventRate.convert(nciAmount, rounding);
+        recognisedAtTheTime = recognisedAtTheTime.plus(atTheTime);
+        nciRecognisedAtTheTime = nciRecognisedAtTheTime.plus(nciAtTheTime);
+        if (inPeriod(event.when)) {
+            chargedFunctional = chargedFunctional.plus(event.amount);
+            nciChargedFunctional = nciChargedFunctional.plus(nciAmount);
+            chargeLoss = chargeLoss.plus(atTheTime);
+            nciChargeLoss = nciChargeLoss.plus(nciAtTheTime);
+        }
+    }
+    void nciChargedFunctional;
+    const functional = grossFunctional.minus(impairedFunctional);
+    const nciFunctional = grossNciFunctional.minus(nciImpairedFunctional);
+    let rate = null;
+    let carrying = functional;
+    let nciCarrying = nciFunctional;
+    if (!sameCurrency) {
+        rate = closingRate(on, "Goodwill");
+        carrying = rate.convert(functional, rounding);
+        nciCarrying = rate.convert(nciFunctional, rounding);
+    }
+    // What the asset was recognised at, less everything taken out of it through
+    // the income statement over its life, each write-off at the rate on its own
+    // day. Whatever is left between that and the closing-rate carrying amount is
+    // the rate's doing and nothing else, which is what sends it to the reserve.
+    //
+    // It falls out of this that a write-off recognised at the closing rate leaves
+    // the exchange difference exactly as it would have been with no write-off at
+    // all: the asset is smaller and so is the figure it is measured against, by
+    // the same amount. That is the test that says the two effects are apart.
+    const atAcquisition = acquisition.goodwill.minus(recognisedAtTheTime);
+    const nciAtAcquisition = acquisition.nciGoodwill.minus(nciRecognisedAtTheTime);
+    const exchangeDifference = carrying.minus(atAcquisition);
+    const nciExchangeDifference = nciCarrying.minus(nciAtAcquisition);
+    return Object.freeze({
+        entity: acquisition.entity,
+        on,
+        functional,
+        grossFunctional,
+        impairedFunctional,
+        carrying,
+        atAcquisition,
+        exchangeDifference,
+        impairmentLoss: chargeLoss,
+        nciImpairmentLoss: nciChargeLoss,
+        groupImpairmentLoss: chargeLoss.minus(nciChargeLoss),
+        recognisedToDate: recognisedAtTheTime,
+        chargedFunctional,
+        nciFunctional,
+        nciCarrying,
+        nciAtAcquisition,
+        nciExchangeDifference,
+        groupExchangeDifference: exchangeDifference.minus(nciExchangeDifference),
+        rate,
+    });
+}
+/** Every acquisition in a group, in the structure's order. */
+export function acquisitions(group, ledgers, inputs, options) {
+    const seen = new Set();
+    for (const input of inputs) {
+        if (seen.has(input.entity)) {
+            throw new GroupError(`${input.entity} is acquired twice in the same group`);
+        }
+        seen.add(input.entity);
+    }
+    const missing = group
+        .consolidated()
+        .filter((e) => e.code !== group.parent && !seen.has(e.code))
+        .map((e) => e.code);
+    if (missing.length > 0) {
+        throw new GroupError(`No acquisition for ${missing.join(", ")}. Without what was paid there is no goodwill ` +
+            `and no way to eliminate the investment against the equity it bought.`);
+    }
+    const order = new Map(group.order.map((code, index) => [code, index]));
+    return Object.freeze([...inputs]
+        .sort((a, b) => (order.get(a.entity) ?? 0) - (order.get(b.entity) ?? 0))
+        .map((input) => acquisitionOf(group, ledgers, input, options)));
+}
+/**
+ * The workings behind goodwill, as a reader would check them.
+ *
+ * Where the acquired company keeps its books in another currency the figures
+ * are shown in both: the subsidiary's currency, which is where the subtraction
+ * happened, and the group's beside it. Showing only the translated column
+ * would leave a reader adding up three sterling figures that do not quite make
+ * the fourth, because each of them is a rounding of something else.
+ */
+export function renderAcquisition(acquisition) {
+    const lines = [];
+    const foreign = acquisition.functional.code !== acquisition.presentation.code;
+    const label = (text, amount, negated = false) => {
+        const take = (money) => (negated ? money.negated() : money).toDecimalString();
+        const presentation = take(amount.presentation).padStart(14);
+        if (!foreign)
+            return `  ${text.padEnd(44)}${presentation}`;
+        return `  ${text.padEnd(44)}${take(amount.functional).padStart(14)}${presentation}`;
+    };
+    lines.push(`${acquisition.entity} — acquired ${acquisition.acquired}, ` +
+        `${acquisition.groupInterest.toPercentString(4)} to the group, ` +
+        `non-controlling interest at ${acquisition.measurement}`);
+    if (foreign) {
+        lines.push(`  ${"".padEnd(44)}${acquisition.functional.code.padStart(14)}` +
+            `${acquisition.presentation.code.padStart(14)}`);
+    }
+    lines.push(label("Consideration transferred", acquisition.considerationIn));
+    lines.push(label("Non-controlling interest at acquisition", acquisition.nciAtAcquisitionIn));
+    lines.push(label(`Net assets acquired${acquisition.netAssetsSupplied ? " (supplied)" : ""}`, acquisition.netAssetsAcquiredIn, true));
+    if (acquisition.bargainGain.isZero) {
+        lines.push(label("Goodwill", acquisition.goodwillIn));
+        if (!acquisition.nciGoodwill.isZero) {
+            lines.push(label("  of which attributable to the outside stake", acquisition.nciGoodwillIn));
+        }
+        if (foreign) {
+            lines.push(`  Measured in ${acquisition.functional.code} and translated at the rate on ` +
+                `${acquisition.acquired}: goodwill on a foreign operation is an asset of that ` +
+                `operation.`);
+        }
+    }
+    else {
+        lines.push(label("Gain on a bargain purchase", acquisition.bargainGainIn, true));
+        lines.push("  A price below the net assets acquired is a gain, not a negative asset.");
+    }
+    return lines.join("\n");
+}

package/dist/group/aggregate.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Bringing several sets of books onto one page.
+ *
+ * Aggregation is the mechanical half of consolidation and it has to happen
+ * before any of the interesting half can. Nothing is eliminated here and
+ * nothing is apportioned: every controlled entity's trial balance is restated
+ * into the group's presentation currency and added account by account, in
+ * full, including the parts of it that belong to somebody else. A subsidiary
+ * held 60% contributes 100% of its assets, because the group controls all of
+ * them; that the other 40% of the equity belongs to outside shareholders is
+ * settled later, as a claim, and not by adding up less of the balance sheet.
+ *
+ * Three things are worth being careful about.
+ *
+ * The first is that each entity's translation carries its own adjustment — the
+ * residual of translating assets at one rate, income at another and equity at
+ * a third — and those adjustments do not cancel. They are kept per entity as
+ * well as in total, because the group's translation reserve is the sum of the
+ * subsidiaries' and a reader is entitled to see which subsidiary moved it.
+ *
+ * The second is that not every entity's trial balance is read on the same day.
+ * A company the group sold in September has a balance sheet the group must
+ * account for and it is September's, not December's; asking its books what
+ * they say in December would be asking about somebody else's company. So each
+ * entity carries the date it was read at, and for every company still in the
+ * group that date is the reporting date.
+ *
+ * The third is that the same account code can mean different things in books
+ * that were never kept on one chart. Nothing here can fix that, but it can say
+ * so: where two entities give a code different names, the disagreement is
+ * reported rather than resolved by whichever entity happened to be first.
+ */
+import type { Currency } from "../money/currency.js";
+import { Money } from "../money/money.js";
+import type { RoundingMode } from "../money/rounding.js";
+import type { AccountType } from "../accounts/types.js";
+import type { CalendarDate, DateRange } from "../ledger/date.js";
+import type { Ledger } from "../ledger/ledger.js";
+import type { AverageMethod } from "../fx/average.js";
+import type { RateTable } from "../fx/table.js";
+import { type Translation } from "../fx/translate.js";
+import { type GroupStructure } from "./structure.js";
+import { type ControlWindow } from "./timeline.js";
+/** The books of each entity, by entity code. */
+export type EntityLedgers = ReadonlyMap<string, Ledger> | Readonly<Record<string, Ledger>>;
+export interface CombinedRow {
+    readonly account: string;
+    readonly name: string;
+    readonly type: AccountType | null;
+    /** The line as the group reads it, in the presentation currency. */
+    readonly total: Money;
+    /** What each entity put into it. Entities contributing nothing are absent. */
+    readonly byEntity: ReadonlyMap<string, Money>;
+}
+export interface EntityContribution {
+    readonly entity: string;
+    readonly functional: Currency;
+    readonly translation: Translation;
+    /** That entity's share of the group's translation reserve. */
+    readonly translationAdjustment: Money;
+    /** How much of the reporting period the group controlled it for. */
+    readonly control: ControlWindow;
+    /**
+     * Whether that window was applied. False only when the caller asked for the
+     * whole period regardless, so a reader is never shown a window beside
+     * figures that ignore it.
+     */
+    readonly windowApplied: boolean;
+    /**
+     * The result taken to reserves before translating, because it was earned
+     * before the group controlled the company. Nil for an entity held all period.
+     */
+    readonly preAcquisitionResult: Money;
+    /**
+     * The date this entity's own books were read at. The reporting date for a
+     * company still in the group; the date control was lost for one that is not.
+     */
+    readonly readAt: CalendarDate;
+}
+export interface NameConflict {
+    readonly account: string;
+    readonly names: readonly {
+        entity: string;
+        name: string;
+    }[];
+}
+export interface Aggregation {
+    readonly presentation: Currency;
+    readonly asAt: CalendarDate;
+    readonly period: DateRange;
+    readonly entities: readonly EntityContribution[];
+    readonly rows: readonly CombinedRow[];
+    /** The sum of the entities' translation adjustments. */
+    readonly translationAdjustment: Money;
+    readonly totalDebit: Money;
+    readonly totalCredit: Money;
+    readonly balanced: boolean;
+    /** Entities in the structure that were not added in, and why. */
+    readonly excluded: readonly {
+        entity: string;
+        reason: string;
+    }[];
+    readonly nameConflicts: readonly NameConflict[];
+}
+export interface AggregationOptions {
+    rates: RateTable;
+    /** Balance sheet date, and the date of the closing rate. */
+    asAt: string;
+    /** The reporting period the average rate covers. */
+    period?: DateRange;
+    averageMethod?: AverageMethod;
+    equityBasis?: "historical" | "closing";
+    /**
+     * Accounts to hold at the rate on the day each movement happened. The
+     * investment in a subsidiary belongs here: it is carried at what was paid,
+     * and what was paid is a fact about the day of the purchase.
+     */
+    historicalAccounts?: readonly string[];
+    rounding?: RoundingMode;
+    includeZero?: boolean;
+    /**
+     * Where an entity's pre-acquisition result goes when its books are closed at
+     * the date control was obtained. Retained earnings by default.
+     */
+    reserves?: string;
+    /**
+     * Add an entity acquired part-way through the period in full anyway, as it
+     * was before. Off by default: the honest answer is that only the part of the
+     * period the group controlled the company for is the group's.
+     */
+    wholePeriodRegardless?: boolean;
+}
+/**
+ * Translate and add every controlled entity's trial balance.
+ *
+ * An entity in the structure with no books is an error rather than a zero: a
+ * consolidation that quietly left out a subsidiary because its file was
+ * missing would balance perfectly and be wrong.
+ */
+export declare function aggregate(group: GroupStructure, ledgers: EntityLedgers, options: AggregationOptions): Aggregation;
+/** A row's contribution from one entity, or zero. */
+export declare function contribution(row: CombinedRow, entity: string): Money;
+export declare function renderAggregation(result: Aggregation): string;