@superheld/summae-core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1251 @@
+import Big from 'big.js';
+
+declare class Currency {
+    readonly code: string;
+    readonly scale: number;
+    private constructor();
+    static of(code: string): Currency;
+    equals(other: Currency): boolean;
+    toJSON(): string;
+    toString(): string;
+}
+
+/**
+ * Betrag = Dezimalwert + Währung, nie Float (Glossar `money`).
+ *
+ * Determinismus-Regeln (determinismus.md §2):
+ * - Rundung: kaufmännisch half-up, von Null weg bei genau .5.
+ * - allocate: Largest-Remainder, Gleichstand → erster Teil; Σ Teile = Betrag, immer.
+ *
+ * Der Betrag liegt intern immer exakt auf der Währungsskala.
+ */
+declare class Money {
+    private readonly amount;
+    readonly currency: Currency;
+    private constructor();
+    private static currencyOf;
+    /**
+     * Exakter Betrag auf Währungsskala. Mehr Nachkommastellen als die Währung
+     * erlaubt sind ein Fehler — hier wird nie still gerundet.
+     */
+    static of(amount: string, currency: Currency | string): Money;
+    /**
+     * Ergebnis einer Rechnung auf Währungsskala bringen: half-up
+     * (2.225 → 2.23, -2.345 → -2.35). Einziger Weg, auf dem Money rundet.
+     */
+    static fromCalculation(value: Big | string, currency: Currency | string): Money;
+    static zero(currency: Currency | string): Money;
+    add(other: Money): Money;
+    subtract(other: Money): Money;
+    negate(): Money;
+    abs(): Money;
+    /** -1, 0 oder 1 */
+    compareTo(other: Money): number;
+    equals(other: Money): boolean;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    /**
+     * Verteilt den Betrag nach Gewichten (determinismus.md §2): Largest-Remainder,
+     * Gleichstand → erster Teil. Σ Teile = Betrag, immer.
+     *
+     * Gewichte: nicht-negative Dezimalwerte (Zahl oder String), Summe > 0.
+     * Negative Beträge werden als negiertes Spiegelbild verteilt.
+     */
+    allocate(...weights: Array<number | string>): Money[];
+    /** Verteilung in n gleiche Teile (Sammelposten-Fünftel, AfA-Monatsraten). */
+    allocateEvenly(parts: number): Money[];
+    /** Betrag als String-Dezimal mit fester Skala, z. B. "1234.56" (datenformat.md). */
+    amountAsString(): string;
+    toJSON(): {
+        amount: string;
+        currency: string;
+    };
+    toString(): string;
+    private static fromMinor;
+    /** Dezimalgewichte verlustfrei auf ganzzahlige Gewichte gleicher Skala bringen. */
+    private static normalizeWeights;
+    private assertSameCurrency;
+}
+
+declare function canonicalJson(value: unknown): string;
+
+/**
+ * Zeitquelle des Kerns (Determinismus-Hook). Bewusst eigenes Interface,
+ * PSR-20-/Temporal-kompatibel im Geist: liefert einen Zeitpunkt.
+ */
+interface Clock {
+    now(): Date;
+}
+/** Echte Systemzeit (Produktion). */
+declare class SystemClock implements Clock {
+    now(): Date;
+}
+/** Feststehende Zeit für Tests und deterministische Läufe. */
+declare class FixedClock implements Clock {
+    private current;
+    private constructor();
+    static at(iso8601: string): FixedClock;
+    now(): Date;
+    advanceMilliseconds(milliseconds: number): void;
+}
+
+declare class Uuid {
+    readonly value: string;
+    private constructor();
+    static fromString(value: string): Uuid;
+    static v7(clock?: Clock): Uuid;
+    equals(other: Uuid): boolean;
+    /** Byteweise = zeitliche Ordnung bei v7. */
+    compareTo(other: Uuid): number;
+    toJSON(): string;
+    toString(): string;
+}
+
+/**
+ * ID-Quelle des Kerns — Port, damit Tests und Determinismus-Läufe die Erzeugung
+ * kontrollieren können. Produktion: UUIDv7.
+ */
+interface IdGenerator {
+    next(): Uuid;
+}
+/** Produktions-Generator: echte UUIDv7 aus Zeit + Zufall. */
+declare class UuidV7IdGenerator implements IdGenerator {
+    private readonly clock;
+    constructor(clock?: Clock);
+    next(): Uuid;
+}
+/**
+ * UUIDv7-förmige IDs aus fester Uhr + Zähler statt Zufall — für Tests und den
+ * Doppellauf-Determinismus-Check der Konformitätssuite (Strom-Hashes enthalten
+ * IDs; zwei Läufe müssen byte-identisch sein).
+ */
+declare class DeterministicIdGenerator implements IdGenerator {
+    private readonly clock;
+    private counter;
+    constructor(clock: Clock);
+    next(): Uuid;
+}
+
+/** Fachlich ungültiger Wert (Betrag, Gewicht, Code, UUID …). */
+declare class InvalidValue extends Error {
+    constructor(message: string);
+}
+/** Verschiedene Währungen lassen sich nicht verrechnen. */
+declare class CurrencyMismatch extends Error {
+    constructor(message: string);
+}
+
+declare class CalendarDate {
+    readonly iso: string;
+    private constructor();
+    static of(iso: string): CalendarDate;
+    compareTo(other: CalendarDate): number;
+    equals(other: CalendarDate): boolean;
+    isBefore(other: CalendarDate): boolean;
+    isAfter(other: CalendarDate): boolean;
+    isBetween(start: CalendarDate, end: CalendarDate): boolean;
+    year(): number;
+    month(): number;
+    lastDayOfMonth(): CalendarDate;
+    firstDayOfNextMonth(): CalendarDate;
+    toJSON(): string;
+    toString(): string;
+}
+
+/**
+ * Kontonummer als String — führende Nullen signifikant (datenformat.md).
+ * Vergleich nach Unicode-Codepoints, keine Locale-Collation: "10" < "9",
+ * "0420" < "1200" < "8400" (determinismus.md §3). JS-`<` auf Strings
+ * vergleicht UTF-16-Code-Units = Codepoints im BMP.
+ */
+declare class AccountNumber {
+    readonly value: string;
+    private constructor();
+    static of(value: string): AccountNumber;
+    compareTo(other: AccountNumber): number;
+    equals(other: AccountNumber): boolean;
+    toJSON(): string;
+    toString(): string;
+}
+
+/**
+ * Verweis auf eine Periode: Geschäftsjahr + Periodennummer (datenformat.md
+ * `periodRef`). `fiscalYear` = Kalenderjahr des GJ-Endes.
+ */
+declare class PeriodRef {
+    readonly fiscalYear: number;
+    readonly period: number;
+    constructor(fiscalYear: number, period: number);
+    /** Chronologisch: erst Jahr, dann Periode. */
+    compareTo(other: PeriodRef): number;
+    equals(other: PeriodRef): boolean;
+    toJSON(): {
+        fiscalYear: number;
+        period: number;
+    };
+}
+
+/**
+ * Zusatzzuordnung einer Buchungsposition: Dimensionstyp + Wert-Code
+ * (datenformat.md). Gültigkeitsprüfung gegen Stammdaten passiert an der
+ * Operation (E_DIMENSION_INVALID), nicht hier.
+ */
+declare class DimensionValue {
+    readonly type: string;
+    readonly code: string;
+    private constructor();
+    static of(type: string, code: string): DimensionValue;
+    equals(other: DimensionValue): boolean;
+    toJSON(): {
+        type: string;
+        code: string;
+    };
+}
+
+/**
+ * Fachlicher Fehler mit Katalog-Code (fehlerkatalog.md). Vertragsteil: gleicher
+ * Verstoß → gleicher Code in allen Implementierungen. `message` ist frei,
+ * `details` trägt beteiligte IDs/Werte.
+ */
+declare class DomainError extends Error {
+    readonly errorCode: string;
+    readonly details: Record<string, unknown>;
+    constructor(errorCode: string, message?: string, details?: Record<string, unknown>);
+}
+
+/** Soll/Haben. */
+type Side = 'debit' | 'credit';
+/**
+ * Kontotyp bestimmt die Saldenmechanik (ledger-modell.md): Bestandskonten
+ * kumulieren über Jahre, Erfolgskonten je Geschäftsjahr.
+ */
+type AccountType = 'asset' | 'liability' | 'equity' | 'expense' | 'revenue';
+/** Bestandskonto: Saldo trägt implizit vor (kein SBK/EBK). */
+declare function isBalanceCarrying(type: AccountType): boolean;
+declare function isAccountType(value: unknown): value is AccountType;
+type AccountStatus = 'active' | 'locked';
+/** GoBD-Lebenszyklus: erfasst (korrigierbar) → festgeschrieben (nur Storno). */
+type EntryStatus = 'entered' | 'finalized';
+type PeriodStatus = 'open' | 'closed';
+type FiscalYearStatus = 'open' | 'closed';
+type OpenItemKind = 'receivable' | 'payable';
+type OpenItemStatus = 'open' | 'partially_settled' | 'settled';
+/**
+ * Ausgleich mit Differenz (api.md G2): Skonto, Forderungsausfall, Kleindifferenz.
+ * Die Differenz muss als Buchungszeile(n) sichtbar sein (§ 17 UStG).
+ */
+type SettlementDifferenceKind = 'discount' | 'bad_debt' | 'minor';
+declare function parseSettlementDifferenceKind(value: unknown): SettlementDifferenceKind | null;
+declare function parseOpenItemKind(value: unknown): OpenItemKind | null;
+
+/**
+ * Konto (ledger-modell.md Aggregat 2). Kein Saldo im Aggregat — Salden sind
+ * Projektionen des Journals, immer.
+ */
+declare class Account {
+    readonly id: Uuid;
+    readonly number: AccountNumber;
+    readonly name: string;
+    readonly type: AccountType;
+    readonly subtype: string | null;
+    private accountStatus;
+    constructor(id: Uuid, number: AccountNumber, name: string, type: AccountType, subtype: string | null, status?: AccountStatus);
+    status(): AccountStatus;
+    isLocked(): boolean;
+    lock(): void;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Buchungsposition — Value Object innerhalb der Buchung (keine eigene Identität;
+ * Referenz = Buchungs-ID + Positionsindex).
+ */
+declare class EntryLine {
+    readonly accountId: Uuid;
+    readonly account: AccountNumber;
+    readonly side: Side;
+    readonly money: Money;
+    readonly dimensions: DimensionValue[];
+    readonly taxTag: Record<string, unknown> | null;
+    constructor(accountId: Uuid, account: AccountNumber, side: Side, money: Money, dimensions?: DimensionValue[], taxTag?: Record<string, unknown> | null);
+    negated(): EntryLine;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Buchung — das wichtigste Aggregat (ledger-modell.md). Entsteht vollständig und
+ * gültig (Validierung im Ledger-Service); Lebenszyklus entered → finalized,
+ * danach nur Storno (neue Buchung mit Rückverweis, Generalumkehr).
+ */
+declare class JournalEntry {
+    readonly id: Uuid;
+    readonly sequenceNumber: number;
+    readonly entryDate: CalendarDate;
+    readonly voucherDate: CalendarDate | null;
+    readonly recordedAt: string;
+    readonly periodRef: PeriodRef;
+    readonly voucherId: Uuid;
+    readonly reverses: Uuid | null;
+    private entryText;
+    private entryLines;
+    private entryReversedBy;
+    private entryStatus;
+    constructor(id: Uuid, sequenceNumber: number, entryDate: CalendarDate, voucherDate: CalendarDate | null, recordedAt: string, periodRef: PeriodRef, voucherId: Uuid, text: string, lines: EntryLine[], reverses?: Uuid | null, reversedBy?: Uuid | null, status?: EntryStatus);
+    status(): EntryStatus;
+    isFinalized(): boolean;
+    text(): string;
+    lines(): EntryLine[];
+    reversedBy(): Uuid | null;
+    changeText(text: string): void;
+    changeLines(lines: EntryLine[]): void;
+    finalize(): void;
+    markReversed(reversalId: Uuid): void;
+    private assertCorrectable;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Beleg (ledger-modell.md Aggregat 4): existiert vor/ohne Buchung, mehrere
+ * Buchungen können ihn referenzieren. Metadaten für EÜR/USt (due, recurring,
+ * economicYear, serviceDate/servicePeriod, partnerId, kind …).
+ */
+interface VoucherProps {
+    readonly id: Uuid;
+    readonly voucherNumber: string;
+    readonly voucherDate: CalendarDate;
+    readonly due?: CalendarDate | null;
+    readonly recurring?: boolean;
+    readonly economicYear?: number | null;
+    readonly supplierTaxationMethod?: string | null;
+    readonly serviceDate?: CalendarDate | null;
+    readonly servicePeriodFrom?: CalendarDate | null;
+    readonly servicePeriodTo?: CalendarDate | null;
+    readonly kind?: string | null;
+    readonly partnerId?: Uuid | null;
+    readonly issuer?: string | null;
+}
+declare class Voucher {
+    readonly id: Uuid;
+    readonly voucherNumber: string;
+    readonly voucherDate: CalendarDate;
+    readonly due: CalendarDate | null;
+    readonly recurring: boolean;
+    readonly economicYear: number | null;
+    readonly supplierTaxationMethod: string | null;
+    readonly serviceDate: CalendarDate | null;
+    readonly servicePeriodFrom: CalendarDate | null;
+    readonly servicePeriodTo: CalendarDate | null;
+    readonly kind: string | null;
+    readonly partnerId: Uuid | null;
+    readonly issuer: string | null;
+    constructor(props: VoucherProps);
+    /** Steuerlich maßgebliches Datum: Leistungsdatum, Fallback Belegdatum. */
+    taxDate(): CalendarDate;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Periode — Entity innerhalb des FiscalYear-Aggregats (lückenlos,
+ * überlappungsfrei; Statuswechsel nur über das Aggregat).
+ */
+declare class Period {
+    readonly number: number;
+    readonly start: CalendarDate;
+    readonly end: CalendarDate;
+    private periodStatus;
+    constructor(number: number, start: CalendarDate, end: CalendarDate, status?: PeriodStatus);
+    status(): PeriodStatus;
+    isOpen(): boolean;
+    contains(date: CalendarDate): boolean;
+    /** Nur über FiscalYear aufrufen (Reihenfolgeprüfung dort). */
+    close(): void;
+    /** Nur über FiscalYear aufrufen (Jahresstatusprüfung dort). */
+    reopen(): void;
+}
+
+interface PeriodDefinition {
+    readonly period: number;
+    readonly start: CalendarDate;
+    readonly end: CalendarDate;
+}
+/**
+ * Geschäftsjahr mit Perioden (ledger-modell.md Aggregat 3). Invarianten:
+ * Perioden lückenlos und überlappungsfrei; Schließen nur in Reihenfolge;
+ * Wiedereröffnen nur vor Jahresabschluss. `year` = Kalenderjahr des GJ-Endes.
+ */
+declare class FiscalYear {
+    readonly id: Uuid;
+    readonly year: number;
+    readonly start: CalendarDate;
+    readonly end: CalendarDate;
+    private readonly periodList;
+    private fiscalStatus;
+    private constructor();
+    static create(id: Uuid, year: number, start: CalendarDate, end: CalendarDate, explicitPeriods?: PeriodDefinition[] | null): FiscalYear;
+    private static monthlyPeriods;
+    status(): FiscalYearStatus;
+    isClosed(): boolean;
+    periods(): Period[];
+    period(number: number): Period;
+    contains(date: CalendarDate): boolean;
+    periodForDate(date: CalendarDate): Period;
+    closePeriod(number: number): Period;
+    reopenPeriod(number: number): Period;
+    /** Reiner Statuswechsel — keine fachliche Buchungswirkung (api.md v0.3). */
+    close(): void;
+    private assertNotClosed;
+}
+
+type AuditChanges = Record<string, {
+    from: unknown;
+    to: unknown;
+}>;
+/**
+ * Audit-Eintrag (datenformat.md v0.3 `auditLog.jsonl`): flacher Vorher/Nachher-
+ * Diff nur der geänderten Felder.
+ */
+declare class AuditRecord {
+    readonly id: Uuid;
+    readonly at: string;
+    readonly actor: string;
+    readonly objectType: string;
+    readonly objectId: Uuid;
+    readonly action: string;
+    readonly changes: AuditChanges;
+    constructor(id: Uuid, at: string, actor: string, objectType: string, objectId: Uuid, action: string, changes?: AuditChanges);
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Einzelner Ausgleich eines offenen Postens. `money` ist der ausgeglichene
+ * OP-Betrag EINSCHLIESSLICH Differenz (api.md G2).
+ */
+declare class Settlement {
+    readonly entryId: Uuid;
+    readonly money: Money;
+    readonly settledAt: CalendarDate;
+    readonly differenceMoney: Money | null;
+    readonly differenceKind: SettlementDifferenceKind | null;
+    constructor(entryId: Uuid, money: Money, settledAt: CalendarDate, differenceMoney?: Money | null, differenceKind?: SettlementDifferenceKind | null);
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Offener Posten (ledger-modell.md Aggregat 5): entsteht aus einer Buchung auf
+ * ein AR/AP-Konto, referenziert Ursprungsbuchung + Position. Invariante:
+ * Σ Ausgleiche ≤ Betrag; Teilausgleiche erlaubt.
+ */
+declare class OpenItem {
+    readonly id: Uuid;
+    readonly kind: OpenItemKind;
+    readonly originEntryId: Uuid;
+    readonly originLineIndex: number;
+    readonly money: Money;
+    readonly voucherId: Uuid;
+    readonly openedAt: CalendarDate;
+    readonly partnerId: Uuid | null;
+    private readonly settlementList;
+    constructor(id: Uuid, kind: OpenItemKind, originEntryId: Uuid, originLineIndex: number, money: Money, voucherId: Uuid, openedAt: CalendarDate, partnerId?: Uuid | null);
+    settlements(): Settlement[];
+    remaining(): Money;
+    /** Restbetrag zum Stichtag (null = heute/alles). */
+    remainingAt(asOf: CalendarDate | null): Money;
+    status(): OpenItemStatus;
+    statusAt(asOf: CalendarDate | null): OpenItemStatus;
+    settle(settlement: Settlement): void;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Ergebnis von `post`: die Buchung plus die dabei entstandenen offenen Posten
+ * (AR/AP-Automatik — folgt mit dem Open-Items-Slice, daher vorerst leer).
+ */
+declare class PostResult {
+    readonly entry: JournalEntry;
+    readonly openItemsCreated: unknown[];
+    constructor(entry: JournalEntry, openItemsCreated: unknown[]);
+}
+
+interface DimensionTypeData {
+    readonly code: string;
+}
+interface DimensionValueData {
+    readonly typeCode: string;
+    readonly code: string;
+}
+interface DimensionRuleData {
+    readonly accountRange: {
+        from: string;
+        to: string;
+    };
+    readonly requiredDimension: string;
+}
+/**
+ * Dimensions-Validierung: Mechanik im Kern, Inhalte als Regelmodul-Daten
+ * (ledger-modell.md). Typen/Werte sind Stammdaten; Pflichtdimensionen kommen
+ * aus `ruleModules.dimensionRules`.
+ */
+declare class DimensionRegistry {
+    private readonly types;
+    private readonly values;
+    private readonly rules;
+    private constructor();
+    static empty(): DimensionRegistry;
+    static fromData(dimensionTypes: DimensionTypeData[], dimensionValues: DimensionValueData[], dimensionRules: DimensionRuleData[]): DimensionRegistry;
+    validateLine(account: AccountNumber, dimensions: DimensionValue[]): void;
+}
+
+/** GWG-Weiche (SF-05): drei Pfade; die Grenzen sind Regelmodul-Daten. */
+type AssetRoute = 'capitalize' | 'immediate_expense' | 'pool';
+declare function parseAssetRoute(value: unknown): AssetRoute | null;
+
+/**
+ * Anlagegut (assets-modell.md): Stammdaten + AfA-Plan + Lebenslauf. Invarianten:
+ * Restbuchwert = AHK − Σ Abschreibungen, nie < 0; keine AfA vor Zugang/nach Abgang.
+ */
+declare class Asset {
+    readonly id: Uuid;
+    readonly name: string;
+    readonly assetClass: string;
+    readonly assetAccount: AccountNumber;
+    readonly acquisitionCost: Money;
+    readonly acquiredOn: CalendarDate;
+    readonly route: AssetRoute;
+    readonly usefulLifeMonths: number | null;
+    readonly monthlySchedule: Money[];
+    readonly voucherId: Uuid;
+    private readonly depreciations;
+    private disposed;
+    private disposedOn;
+    constructor(id: Uuid, name: string, assetClass: string, assetAccount: AccountNumber, acquisitionCost: Money, acquiredOn: CalendarDate, route: AssetRoute, usefulLifeMonths: number | null, monthlySchedule: Money[], voucherId: Uuid);
+    isDisposed(): boolean;
+    assertActive(): void;
+    dispose(disposedOn: CalendarDate): void;
+    planMonthDate(planMonth: number): CalendarDate;
+    isMonthBooked(planMonth: number): boolean;
+    recordDepreciation(planMonth: number, date: CalendarDate, amount: Money, entryId: Uuid): void;
+    accumulatedDepreciationAt(asOf: CalendarDate | null): Money;
+    bookValueAt(asOf: CalendarDate | null): Money;
+    scheduleSummary(): Record<string, string>;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * Geschäftspartner (datenformat.md v0.4) — bewusst schlank: OP-je-Partner,
+ * igL-Nachweis (USt-IdNr.), ZM-Grundlage, DATEV-Stammdaten.
+ */
+declare class Partner {
+    readonly id: Uuid;
+    private readonly accountNumbers;
+    private readonly address;
+    private partnerName;
+    private partnerKind;
+    private partnerVatId;
+    private partnerPaymentTermsDays;
+    constructor(id: Uuid, name: string, kind: string, vatId: string | null, paymentTermsDays: number | null, accountNumbers?: string[], address?: Record<string, unknown>);
+    name(): string;
+    vatId(): string | null;
+    update(input: Record<string, unknown>): AuditChanges;
+    toJSON(): Record<string, unknown>;
+}
+
+/** Kontonummern je Mandant eindeutig — der Adapter MUSS das zusichern. */
+interface AccountRepository {
+    add(account: Account): void;
+    save(account: Account): void;
+    byNumber(number: AccountNumber): Account | null;
+    byId(id: Uuid): Account | null;
+    /** sortiert nach Kontonummer (Codepoints) */
+    all(): Account[];
+}
+interface FiscalYearRepository {
+    add(fiscalYear: FiscalYear): void;
+    save(fiscalYear: FiscalYear): void;
+    byYear(year: number): FiscalYear | null;
+    forDate(date: CalendarDate): FiscalYear | null;
+    /** sortiert nach Jahr */
+    all(): FiscalYear[];
+}
+/**
+ * Journal: append-only, lückenlose sequenceNumber je Geschäftsjahr. `save`
+ * persistiert Statuswechsel; der Eintrag selbst wird nie gelöscht.
+ */
+interface JournalRepository {
+    append(entry: JournalEntry): void;
+    save(entry: JournalEntry): void;
+    byId(id: Uuid): JournalEntry | null;
+    nextSequenceNumber(fiscalYear: number): number;
+    /** sortiert nach (fiscalYear, sequenceNumber) */
+    all(): JournalEntry[];
+    /** sortiert nach sequenceNumber */
+    forFiscalYear(fiscalYear: number): JournalEntry[];
+}
+interface VoucherRepository {
+    add(voucher: Voucher): void;
+    byId(id: Uuid): Voucher | null;
+    /** sortiert nach ID */
+    all(): Voucher[];
+}
+interface OpenItemRepository {
+    add(item: OpenItem): void;
+    save(item: OpenItem): void;
+    byId(id: Uuid): OpenItem | null;
+    /** Posten, die aus dieser Buchung entstanden */
+    byOriginEntry(entryId: Uuid): OpenItem[];
+    /** in Entstehungsreihenfolge */
+    all(): OpenItem[];
+}
+/** Audit-Trail ist Formatbestandteil (datenformat.md v0.3): append-only. */
+interface AuditTrail {
+    append(record: AuditRecord): void;
+    /** in Erfassungsreihenfolge */
+    all(): AuditRecord[];
+}
+interface AssetRepository {
+    add(asset: Asset): void;
+    save(asset: Asset): void;
+    byId(id: Uuid): Asset | null;
+    /** in Zugangsreihenfolge */
+    all(): Asset[];
+}
+interface PartnerRepository {
+    add(partner: Partner): void;
+    save(partner: Partner): void;
+    byId(id: Uuid): Partner | null;
+    /** sortiert nach Name, dann ID */
+    all(): Partner[];
+}
+
+/**
+ * Domain Service `post` und Verwandte (ledger-modell.md). Prüfreihenfolge beim
+ * Buchen ist Vertragsbestandteil (api.md):
+ *   1. Struktur (E_ENTRY_TOO_FEW_LINES, E_ENTRY_INVALID_AMOUNT)
+ *   2. Referenzen (E_ENTRY_NO_VOUCHER, E_VOUCHER_UNKNOWN, E_ACCOUNT_UNKNOWN,
+ *      E_ACCOUNT_LOCKED, E_DIMENSION_INVALID)
+ *   3. Bilanzgleichung (E_ENTRY_UNBALANCED)
+ *   4. Zeitlicher Kontext (E_PERIOD_UNKNOWN, E_PERIOD_CLOSED)
+ * Nur der erste Fehler wird gemeldet.
+ */
+declare class Ledger {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly fiscalYears;
+    private readonly vouchers;
+    private readonly journal;
+    private readonly openItems;
+    private readonly audit;
+    private readonly dimensions;
+    private readonly clock;
+    private readonly ids;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, fiscalYears: FiscalYearRepository, vouchers: VoucherRepository, journal: JournalRepository, openItems: OpenItemRepository, audit: AuditTrail, dimensions: DimensionRegistry, clock: Clock, ids: IdGenerator);
+    post(input: Record<string, unknown>): PostResult;
+    /**
+     * AR/AP-Automatik: Soll auf Forderungskonto → receivable, Haben auf
+     * Verbindlichkeitskonto → payable. Stornobuchungen erzeugen keine Posten.
+     */
+    private createOpenItems;
+    /**
+     * Ausgleich: Zuordnung Zahlung → offene(r) Posten, auch teilweise; immer
+     * explizit, kein FIFO (determinismus.md §3). Differenzen (Skonto/Ausfall/
+     * Kleindifferenz) nach api.md G2. Erst vollständig validieren, dann anwenden.
+     */
+    settle(input: Record<string, unknown>): OpenItem[];
+    private parseSettlementMoney;
+    private parseDifference;
+    correct(input: Record<string, unknown>): JournalEntry;
+    finalize(input: Record<string, unknown>): number;
+    reverse(input: Record<string, unknown>): JournalEntry;
+    closePeriod(input: Record<string, unknown>): {
+        fiscalYear: number;
+        period: number;
+        status: string;
+    };
+    reopenPeriod(input: Record<string, unknown>): {
+        fiscalYear: number;
+        period: number;
+        status: string;
+    };
+    closeFiscalYear(input: Record<string, unknown>): FiscalYear;
+    createFiscalYear(input: Record<string, unknown>): FiscalYear;
+    createAccount(input: Record<string, unknown>): Account;
+    lockAccount(input: Record<string, unknown>): Account;
+    importChartOfAccounts(input: Record<string, unknown>): number;
+    private actor;
+    private parseLine;
+    private requireVoucher;
+    private resolveLines;
+    private assertBalanced;
+    private parseEntryDate;
+    private openPeriodFor;
+    private requireEntry;
+    private requireFiscalYear;
+    private periodNumber;
+    private buildAccount;
+    private recordAudit;
+    private now;
+}
+
+declare class InMemoryAccountRepository implements AccountRepository {
+    private readonly byNumberMap;
+    private readonly byIdMap;
+    add(account: Account): void;
+    save(_account: Account): void;
+    byNumber(number: AccountNumber): Account | null;
+    byId(id: Uuid): Account | null;
+    all(): Account[];
+}
+declare class InMemoryFiscalYearRepository implements FiscalYearRepository {
+    private readonly byYearMap;
+    add(fiscalYear: FiscalYear): void;
+    save(_fiscalYear: FiscalYear): void;
+    byYear(year: number): FiscalYear | null;
+    forDate(date: CalendarDate): FiscalYear | null;
+    all(): FiscalYear[];
+}
+declare class InMemoryJournalRepository implements JournalRepository {
+    private readonly entries;
+    private readonly byIdMap;
+    private readonly sequences;
+    append(entry: JournalEntry): void;
+    save(_entry: JournalEntry): void;
+    byId(id: Uuid): JournalEntry | null;
+    nextSequenceNumber(fiscalYear: number): number;
+    all(): JournalEntry[];
+    forFiscalYear(fiscalYear: number): JournalEntry[];
+}
+declare class InMemoryVoucherRepository implements VoucherRepository {
+    private readonly byIdMap;
+    add(voucher: Voucher): void;
+    byId(id: Uuid): Voucher | null;
+    all(): Voucher[];
+}
+declare class InMemoryOpenItemRepository implements OpenItemRepository {
+    private readonly items;
+    private readonly byIdMap;
+    add(item: OpenItem): void;
+    save(_item: OpenItem): void;
+    byId(id: Uuid): OpenItem | null;
+    byOriginEntry(entryId: Uuid): OpenItem[];
+    all(): OpenItem[];
+}
+declare class InMemoryAuditTrail implements AuditTrail {
+    private readonly records;
+    append(record: AuditRecord): void;
+    all(): AuditRecord[];
+}
+declare class InMemoryPartnerRepository implements PartnerRepository {
+    private readonly byIdMap;
+    add(partner: Partner): void;
+    save(_partner: Partner): void;
+    byId(id: Uuid): Partner | null;
+    all(): Partner[];
+}
+declare class InMemoryAssetRepository implements AssetRepository {
+    private readonly items;
+    private readonly byIdMap;
+    add(asset: Asset): void;
+    save(_asset: Asset): void;
+    byId(id: Uuid): Asset | null;
+    all(): Asset[];
+}
+
+/**
+ * Anlagen-Nebenbuch (assets-modell.md): GWG-Weiche beim Zugang, AfA-Lauf
+ * idempotent je Lauf-Ziel, Buchungen über den Ledger (sofort festgeschrieben).
+ * AfA-Verteilung: Monatswerte = allocate der AHK über die Laufzeit (flach).
+ */
+declare class AssetService {
+    private readonly baseCurrency;
+    private readonly assets;
+    private readonly fiscalYears;
+    private readonly vouchers;
+    private readonly ledger;
+    private readonly ids;
+    private ruleModule;
+    constructor(baseCurrency: Currency, assets: AssetRepository, fiscalYears: FiscalYearRepository, vouchers: VoucherRepository, ledger: Ledger, ids: IdGenerator);
+    setRuleModule(ruleModule: Record<string, unknown>): void;
+    acquire(input: Record<string, unknown>): Record<string, unknown>;
+    dispose(input: Record<string, unknown>): Record<string, unknown>;
+    runDepreciation(input: Record<string, unknown>): Record<string, unknown>;
+    requireAsset(assetId: unknown): Asset;
+    private yearTarget;
+    private monthTarget;
+    private monthAmounts;
+    private bookingDate;
+    private postMachineEntry;
+    private depreciationVoucher;
+    private resolveRoute;
+    private thresholds;
+    private usefulLifeMonths;
+    private counterAccount;
+    private depreciationExpenseAccount;
+    private gwgExpenseAccount;
+    private assetAccount;
+    private parseMoney;
+}
+
+/**
+ * Abrechnungslauf (costing-modell.md Aggregat 1): je Periode + Version eindeutig;
+ * Wiederholung erzeugt neue Version. draft → released.
+ */
+declare class CostingRun {
+    readonly id: Uuid;
+    readonly period: PeriodRef;
+    readonly version: number;
+    readonly primary: Map<string, Money>;
+    readonly afterAllocation: Map<string, Money>;
+    readonly grandTotal: Money;
+    private runStatus;
+    constructor(id: Uuid, period: PeriodRef, version: number, primary: Map<string, Money>, afterAllocation: Map<string, Money>, grandTotal: Money);
+    status(): string;
+    release(): void;
+}
+
+/**
+ * KLR-Abrechnung (costing-modell.md): eigener Rechnungskreis — das Fibu-Journal
+ * bleibt unberührt. Primärkostenübernahme über costCenter-Dimension, Umlage per
+ * Stufenleiter (zyklenfrei, E_COSTING_CYCLE), Verteilung per Money.allocate.
+ */
+declare class CostingService {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly journal;
+    private readonly ids;
+    private schemeSteps;
+    private readonly runs;
+    private readonly versions;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, journal: JournalRepository, ids: IdGenerator);
+    setAllocationScheme(input: Record<string, unknown>): Record<string, unknown>;
+    run(input: Record<string, unknown>): CostingRun;
+    release(input: Record<string, unknown>): CostingRun;
+    costAllocationSheet(params: Record<string, unknown>): Record<string, unknown>;
+    private serializeTotals;
+    private requireRun;
+    private assertAcyclic;
+}
+
+/** Partner-Operationen (api.md v0.4): createPartner / updatePartner mit Audit. */
+declare class PartnerService {
+    private readonly partners;
+    private readonly audit;
+    private readonly clock;
+    private readonly ids;
+    constructor(partners: PartnerRepository, audit: AuditTrail, clock: Clock, ids: IdGenerator);
+    create(input: Record<string, unknown>): Partner;
+    update(input: Record<string, unknown>): Partner;
+    require(partnerId: unknown): Partner;
+    private recordAudit;
+}
+
+/**
+ * Regelversion eines Steuerschlüssels mit Gültigkeitszeitraum. Inhalte sind
+ * Regelmodul-Daten — Code zitiert kein Gesetz. mechanism `reverse_charge`:
+ * USt- und VSt-Position gleichzeitig; `intra_community_supply`: steuerfrei.
+ */
+declare class TaxCodeVersion {
+    readonly validFrom: CalendarDate;
+    readonly validTo: CalendarDate | null;
+    readonly rate: string;
+    readonly taxAccount: string;
+    readonly reportingKey: string | null;
+    readonly mechanism: string;
+    readonly inputTaxAccount: string | null;
+    readonly inputReportingKey: string | null;
+    readonly baseReportingKey: string | null;
+    constructor(validFrom: CalendarDate, validTo: CalendarDate | null, rate: string, taxAccount: string, reportingKey: string | null, mechanism?: string, inputTaxAccount?: string | null, inputReportingKey?: string | null, baseReportingKey?: string | null);
+    coversDate(date: CalendarDate): boolean;
+}
+
+/**
+ * Steuerschlüssel (tax-modell.md Aggregat 1): gebündelter Steuersachverhalt als
+ * Liste von Regelversionen. Versionswahl folgt dem Belegdatum.
+ */
+declare class TaxCode {
+    readonly code: string;
+    readonly versions: TaxCodeVersion[];
+    readonly datevBu: string | null;
+    constructor(code: string, versions: TaxCodeVersion[], datevBu?: string | null);
+    versionFor(date: CalendarDate): TaxCodeVersion;
+}
+
+/** Geladene, validierte Form der Steuerschlüssel-Regelmodul-Daten. */
+declare class TaxCodeRegistry {
+    private readonly codes;
+    private constructor();
+    static empty(): TaxCodeRegistry;
+    static fromData(data: Array<Record<string, unknown>>): TaxCodeRegistry;
+    allVersions(): TaxCodeVersion[];
+    datevBuFor(code: string): string | null;
+    get(code: string): TaxCode;
+    versionFor(code: string, date: CalendarDate): TaxCodeVersion;
+}
+
+/**
+ * ZM-Grundlage (v0.4, SF-21): innergemeinschaftliche Umsätze je USt-IdNr. und
+ * Zeitraum — aus Kennzahl-Tags der igL-Schlüssel, Partner über den Beleg.
+ */
+declare class EcSalesListProjection {
+    private readonly baseCurrency;
+    private readonly journal;
+    private readonly vouchers;
+    private readonly partners;
+    private readonly registry;
+    constructor(baseCurrency: Currency, journal: JournalRepository, vouchers: VoucherRepository, partners: PartnerRepository, registry: TaxCodeRegistry);
+    compute(params: Record<string, unknown>): {
+        rows: Array<Record<string, string>>;
+    };
+}
+
+/**
+ * Summen- und Saldenliste (SuSa) — Spalten verbindlich (api.md v0.4):
+ * - openingBalance: kumulierter Saldo VOR dem GJ (0 bei Erfolgskonten)
+ * - debitTotal/creditTotal: Verkehrszahlen des Zeitraums (GJ bis Periode)
+ * - balance = openingBalance + debitTotal − creditTotal (Soll-Salden positiv)
+ * Sortierung: Kontonummer nach Codepoints (determinismus.md §3).
+ */
+declare class TrialBalanceProjection {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly journal;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, journal: JournalRepository);
+    compute(params: Record<string, unknown>): {
+        rows: Array<Record<string, string>>;
+    };
+}
+
+/**
+ * OP-Liste: deterministisch, asOf-fähig (Zeitreise über settledAt). Sortierung:
+ * voucherDate, dann sequenceNumber (determinismus.md §3).
+ */
+declare class OpenItemsProjection {
+    private readonly openItems;
+    private readonly vouchers;
+    private readonly journal;
+    constructor(openItems: OpenItemRepository, vouchers: VoucherRepository, journal: JournalRepository);
+    compute(params: Record<string, unknown>): {
+        items: Array<Record<string, unknown>>;
+    };
+    private voucherDate;
+    private sequenceNumber;
+    private serializeItem;
+}
+
+/**
+ * Kontoblatt: alle Bewegungen eines Kontos im Geschäftsjahr mit laufendem Saldo.
+ * Anfangsbestand = kumulierte Vorjahre für Bestandskonten, null für Erfolgskonten.
+ * Ordnung: sequenceNumber (determinismus.md §3).
+ */
+declare class AccountSheetProjection {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly journal;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, journal: JournalRepository);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * Änderungshistorie als Projektion (F-CORE-014). Reihenfolge =
+ * Erfassungsreihenfolge des Audit-Trails.
+ */
+declare class AuditLogProjection {
+    private readonly audit;
+    constructor(audit: AuditTrail);
+    compute(params: Record<string, unknown>): {
+        records: Array<Record<string, unknown>>;
+    };
+}
+
+/**
+ * Steuerliches Mandantenprofil (tax-modell.md Aggregat 2): Versteuerungsart,
+ * Kleinunternehmer-Status mit Gültigkeitszeitraum (unterjähriger Wechsel,
+ * SF-11), Voranmeldungszeitraum.
+ */
+declare class TaxProfile {
+    private readonly method;
+    private smallBusiness;
+    private readonly period;
+    private constructor();
+    static fromData(data: Record<string, unknown>): TaxProfile;
+    static default(): TaxProfile;
+    taxationMethod(): string;
+    isCashBasis(): boolean;
+    vatPeriod(): string;
+    smallBusinessAt(date: CalendarDate): boolean;
+    setSmallBusiness(validFrom: CalendarDate, value: boolean): void;
+    private static sorted;
+    toJSON(): Record<string, unknown>;
+}
+
+/**
+ * USt-VA-Kennzahlen über taxTags (SF-09). Soll: Buchungs-/Leistungsdatum; Ist:
+ * folgt OP-Ausgleichen (anteilig half-up, Schlussrest exakt). Bemessungsgrund-
+ * lagen je Kennzahl auf volle Euro abgerundet, Steuer centgenau (api.md v0.3).
+ */
+declare class VatReturnProjection {
+    private readonly baseCurrency;
+    private readonly journal;
+    private readonly openItems;
+    private readonly vouchers;
+    private readonly accounts;
+    private readonly registry;
+    private readonly profile;
+    constructor(baseCurrency: Currency, journal: JournalRepository, openItems: OpenItemRepository, vouchers: VoucherRepository, accounts: AccountRepository, registry: TaxCodeRegistry, profile: TaxProfile);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+    private registryDirections;
+    private accountDirection;
+    private entryContributions;
+    private tagBaseMoney;
+    private allocateToSettlements;
+    private proportional;
+    private inQuarter;
+}
+
+interface MappingLeaf {
+    key: string;
+    label: string;
+    side: string | null;
+    ranges: Array<{
+        from: string;
+        to: string;
+    }>;
+    numbers: string[];
+    includeNonCash: boolean;
+    includesNetIncome: boolean;
+    parents: string[];
+}
+/** Trifft ein Blatt eine Kontonummer? (Einzelnummern oder Codepoint-Bereiche.) */
+declare function leafMatches(leaf: MappingLeaf, accountNumber: string): boolean;
+/**
+ * Gliederungs-Mapping (datenformat.md v0.2): ordnet Konten Positionen zu —
+ * gleiche Struktur für Bilanz, GuV, EÜR-Zeilen und VA-Kennzahlen.
+ */
+declare class Mapping {
+    readonly id: string;
+    readonly kind: string;
+    readonly version: string;
+    readonly leaves: MappingLeaf[];
+    constructor(id: string, kind: string, version: string, leaves: MappingLeaf[]);
+    static fromData(data: Record<string, unknown>): Mapping;
+    private static collectLeaves;
+    leafFor(accountNumber: string): MappingLeaf | null;
+}
+
+/** Geladene Mappings eines Mandanten (mutierbar über importMapping). */
+declare class MappingRegistry {
+    private readonly byIdMap;
+    static empty(): MappingRegistry;
+    static fromRuleModules(raw: unknown[]): MappingRegistry;
+    add(mapping: Mapping): void;
+    byId(id: string): Mapping | null;
+}
+
+/**
+ * GuV als Projektion über ein Mapping (SF-09). Vorzeichen: Haben − Soll
+ * (Erträge positiv, Aufwand negativ); netIncome = Summe der Positionen.
+ * fromPeriod/throughPeriod grenzen ab (Monats-GuV als BWA-Grundlage).
+ */
+declare class IncomeStatementProjection {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly journal;
+    private readonly mappings;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, journal: JournalRepository, mappings: MappingRegistry);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * Bilanz als Projektion (SF-10): kumulativ zum Stichtag. Position mit
+ * includesNetIncome enthält die kumulierten Jahresergebnisse + eigenen Saldo.
+ * Seite (v0.5/F-007): `side` am Wurzelknoten; assets = Soll−Haben,
+ * liabilitiesAndEquity = Haben−Soll. Default: assets.
+ */
+declare class BalanceSheetProjection {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly journal;
+    private readonly mappings;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, journal: JournalRepository, mappings: MappingRegistry);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * EÜR als Projektion über das doppische Journal — Regeln R1–R7
+ * (euer-projektions-beweis.md). Zahlungswirksamkeit über Geldkonten, OP-Link bei
+ * Ausgleich (anteilig), 10-Tage-Regel, USt zahlungswirksam, R7 includeNonCash.
+ * Kalenderjahrgebunden: abweichendes GJ → E_CASHBASIS_DEVIATING_FISCAL_YEAR.
+ */
+declare class CashBasisProjection {
+    private readonly baseCurrency;
+    private readonly accounts;
+    private readonly journal;
+    private readonly openItems;
+    private readonly vouchers;
+    private readonly fiscalYears;
+    private readonly mappings;
+    constructor(baseCurrency: Currency, accounts: AccountRepository, journal: JournalRepository, openItems: OpenItemRepository, vouchers: VoucherRepository, fiscalYears: FiscalYearRepository, mappings: MappingRegistry);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+    private assertCalendarYearFiscalYears;
+    private bankFlow;
+    private assignYear;
+    private inTenDayWindow;
+    private sourceLines;
+    private proportional;
+    private label;
+    private serializeBucket;
+}
+
+/**
+ * Anlageverzeichnis (Pflicht auch bei EÜR, § 4 Abs. 3 S. 5 EStG). Sortierung:
+ * Zugangsdatum, dann ID (deterministisch).
+ */
+declare class AssetRegisterProjection {
+    private readonly assets;
+    constructor(assets: AssetRepository);
+    compute(params: Record<string, unknown>): {
+        assets: Array<Record<string, unknown>>;
+    };
+}
+
+/**
+ * GoBD-Z3-Export (SF-14): Manifest mit SHA-256-Strom-Hashes über RFC-8785-
+ * kanonisierte Zeilen, Feldkatalog, Journal vollständig in sequenceNumber-
+ * Reihenfolge. auditLog ist immer Teil des Exports (v0.5/F-005).
+ */
+declare class JournalExportProjection {
+    private readonly tenantId;
+    private readonly tenantName;
+    private readonly baseCurrency;
+    private readonly journal;
+    private readonly accounts;
+    private readonly vouchers;
+    private readonly partners;
+    private readonly audit;
+    private readonly clock;
+    constructor(tenantId: Uuid, tenantName: string, baseCurrency: Currency, journal: JournalRepository, accounts: AccountRepository, vouchers: VoucherRepository, partners: PartnerRepository, audit: AuditTrail, clock: Clock);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+    private static formatEntry;
+    private fieldCatalog;
+}
+
+/**
+ * DATEV-Export (F-IO-005): Buchungsstapel, Kontenbeschriftungen, Partner-
+ * Stammdaten. Steuerzeilen werden DATEV-seitig aus dem BU-Schlüssel erzeugt und
+ * deshalb in die Basiszeile gefaltet; zusammengesetzte Buchungen in Teilzeilen.
+ */
+declare class DatevExportProjection {
+    private readonly journal;
+    private readonly accounts;
+    private readonly vouchers;
+    private readonly partners;
+    private readonly registry;
+    constructor(journal: JournalRepository, accounts: AccountRepository, vouchers: VoucherRepository, partners: PartnerRepository, registry: TaxCodeRegistry);
+    compute(params: Record<string, unknown>): Record<string, unknown>;
+    private entryRows;
+    private splitEntry;
+    private accountRows;
+    private partnerRows;
+}
+
+/**
+ * Mapping-Import (api.md): Überlappung → E_MAPPING_OVERLAP; Lücken sind kein
+ * Fehler, sondern gapWarnings[] mit Auffangposition `_unassigned`. Geprüft gegen
+ * die real existierenden Konten je Mapping-Art.
+ */
+declare class MappingImporter {
+    private readonly accounts;
+    private readonly registry;
+    constructor(accounts: AccountRepository, registry: MappingRegistry);
+    import(input: Record<string, unknown>): Record<string, unknown>;
+    private relevantAccounts;
+}
+
+/**
+ * Steuerexpansion (tax-modell.md): side-effect-free. Determinismus (§2):
+ * USt pro Beleg je Steuersatz — Netto-Summe je Schlüssel, Steuer berechnen,
+ * EINMAL half-up runden. Versionswahl nach Leistungs-/Belegdatum.
+ * Kleinunternehmer (§ 19): keine Steuerpositionen, Brutto = Netto.
+ */
+declare class TaxService {
+    private readonly baseCurrency;
+    private readonly registry;
+    private readonly profileValue;
+    private readonly journal;
+    constructor(baseCurrency: Currency, registry: TaxCodeRegistry, profileValue: TaxProfile, journal: JournalRepository);
+    profile(): TaxProfile;
+    registryHandle(): TaxCodeRegistry;
+    expand(input: Record<string, unknown>): Record<string, unknown>;
+    setProfile(input: Record<string, unknown>): TaxProfile;
+    private tag;
+    private parseDate;
+    private parseMoney;
+}
+
+/**
+ * Mandant: buchführende Einheit, oberste Datengrenze (Glossar `tenant`). Bündelt
+ * Ports + Services einer Instanz. Wächst mit den Slices (Tax/Partner/Asset/
+ * Costing folgen); der Adapter ersetzt nur die Ports.
+ */
+declare class Tenant {
+    readonly id: Uuid;
+    readonly name: string;
+    readonly baseCurrency: Currency;
+    readonly accounts: AccountRepository;
+    readonly fiscalYears: FiscalYearRepository;
+    readonly vouchers: VoucherRepository;
+    readonly journal: JournalRepository;
+    readonly openItems: OpenItemRepository;
+    readonly assets: AssetRepository;
+    readonly partners: PartnerRepository;
+    readonly audit: AuditTrail;
+    readonly ledger: Ledger;
+    readonly tax: TaxService;
+    readonly assetService: AssetService;
+    readonly costing: CostingService;
+    readonly partnerService: PartnerService;
+    readonly mappings: MappingRegistry;
+    readonly clock: Clock;
+    readonly ids: IdGenerator;
+    constructor(id: Uuid, name: string, baseCurrency: Currency, accounts: AccountRepository, fiscalYears: FiscalYearRepository, vouchers: VoucherRepository, journal: JournalRepository, openItems: OpenItemRepository, assets: AssetRepository, partners: PartnerRepository, audit: AuditTrail, ledger: Ledger, tax: TaxService, assetService: AssetService, costing: CostingService, partnerService: PartnerService, mappings: MappingRegistry, clock: Clock, ids: IdGenerator);
+    static inMemory(name: string, baseCurrency: Currency, clock?: Clock, ids?: IdGenerator, dimensions?: DimensionRegistry, taxCodes?: TaxCodeRegistry, taxProfile?: TaxProfile, mappings?: MappingRegistry): Tenant;
+}
+
+/**
+ * Generischer Einstieg in alle Operationen und Projektionen eines Mandanten —
+ * die Schnittstelle für CLI und Konformitäts-Runner. Namen exakt nach api.md.
+ * Wächst mit den Slices; Unimplementiertes meldet E_NOT_IMPLEMENTED.
+ */
+declare class TenantOperations {
+    private readonly tenant;
+    constructor(tenant: Tenant);
+    execute(op: string, input: Record<string, unknown>): Record<string, unknown>;
+    project(name: string, params: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * Anwendungsschicht-Komposition `postVoucher` (api.md, Teil der Spec): SF-02/03
+ * in einem Aufruf — Beleg anlegen, expandTax, post, OP-Anlage.
+ */
+declare class PostVoucherService {
+    private readonly tenant;
+    constructor(tenant: Tenant);
+    post(input: Record<string, unknown>): Record<string, unknown>;
+}
+
+/**
+ * `createTenant` (SF-01): Mandant per Profil anlegen — sofort buchbar. Profile
+ * sind versionierte Regelmodul-Daten; der Mandant pinnt die Version.
+ */
+declare class TenantFactory {
+    private readonly ruleModules;
+    private readonly clock;
+    private readonly ids;
+    constructor(ruleModules: Record<string, unknown>, clock: Clock, ids: IdGenerator);
+    create(input: Record<string, unknown>): {
+        tenant: Tenant;
+        result: Record<string, unknown>;
+    };
+    private findById;
+}
+
+export { Account, AccountNumber, type AccountRepository, AccountSheetProjection, type AccountStatus, type AccountType, Asset, AssetRegisterProjection, type AssetRepository, type AssetRoute, AssetService, type AuditChanges, AuditLogProjection, AuditRecord, type AuditTrail, BalanceSheetProjection, CalendarDate, CashBasisProjection, type Clock, CostingRun, CostingService, Currency, CurrencyMismatch, DatevExportProjection, DeterministicIdGenerator, DimensionRegistry, type DimensionRuleData, type DimensionTypeData, DimensionValue, type DimensionValueData, DomainError, EcSalesListProjection, EntryLine, type EntryStatus, FiscalYear, type FiscalYearRepository, type FiscalYearStatus, FixedClock, type IdGenerator, InMemoryAccountRepository, InMemoryAssetRepository, InMemoryAuditTrail, InMemoryFiscalYearRepository, InMemoryJournalRepository, InMemoryOpenItemRepository, InMemoryPartnerRepository, InMemoryVoucherRepository, IncomeStatementProjection, InvalidValue, JournalEntry, JournalExportProjection, type JournalRepository, Ledger, Mapping, MappingImporter, type MappingLeaf, MappingRegistry, Money, OpenItem, type OpenItemKind, type OpenItemRepository, type OpenItemStatus, OpenItemsProjection, Partner, type PartnerRepository, PartnerService, Period, type PeriodDefinition, PeriodRef, type PeriodStatus, PostResult, PostVoucherService, Settlement, type SettlementDifferenceKind, type Side, SystemClock, TaxCode, TaxCodeRegistry, TaxCodeVersion, TaxProfile, TaxService, Tenant, TenantFactory, TenantOperations, TrialBalanceProjection, Uuid, UuidV7IdGenerator, VatReturnProjection, Voucher, type VoucherProps, type VoucherRepository, canonicalJson, isAccountType, isBalanceCarrying, leafMatches, parseAssetRoute, parseOpenItemKind, parseSettlementDifferenceKind };