@fin.cx/skr 1.3.0 → 2.0.0

package/ts/skr.migrate.ts

@@ -0,0 +1,268 @@
+/**
+ * v1 -> v2 data migration (offline, idempotent, additive):
+ *
+ *  M001 cents backfill — every legacy JournalEntry line gains exact-cent v2
+ *       fields (amountCents/side/counterAccount/buKey) next to the kept
+ *       float fields; sub-cent drift beyond the guard aborts loudly.
+ *  M002 unify journal — standalone legacy Transactions (not referenced by any
+ *       JournalEntry) become synthesized two-line entries (legacyImport);
+ *       legacy entries get schemaVersion 2 so aggregations see them.
+ *       v1 'reversed' status maps to 'posted' (kept as legacyStatus) so
+ *       original+reversal pairs net to zero in aggregations.
+ *  M003 sequence + chain — all v2 entries without a sequenceNumber are
+ *       appended to the hash chain per (skrType, fiscalYear) in deterministic
+ *       order (postedAt/createdAt/date, then id).
+ *
+ * Legacy float fields are never removed; the Transaction collection is kept
+ * as a frozen read model. The returned report is a Verfahrensdokumentation
+ * artifact — persist it with your records.
+ */
+import * as plugins from './plugins.js';
+import * as core from './core/index.js';
+import { getDbSync } from './skr.database.js';
+import { JOURNAL_ENTRY_COLLECTION } from './skr.period.js';
+import { buildHashPayload } from './skr.posting.js';
+import { mapNumericPostingKey } from './skr.txview.js';
+import type { TSKRType } from './skr.types.js';
+
+const { centsFromFloat } = plugins.calculation;
+
+export interface IMigrationReport {
+  startedAt: Date;
+  finishedAt: Date | null;
+  m001: {
+    journalEntriesBackfilled: number;
+    transactionsBackfilled: number;
+    maxDriftCents: number;
+  };
+  m002: { legacyEntriesUpgraded: number; transactionsSynthesized: number };
+  m003: Array<{
+    skrType: string;
+    fiscalYear: number;
+    chainedEntries: number;
+    headHash: string;
+  }>;
+}
+
+/** drift guard for legacy float data (plan: abort on drift > 0.5 cent) */
+const LEGACY_DRIFT_CENTS = 0.5;
+
+function toCents(value: number, driftTracker: { max: number }): number {
+  const exact = value * 100;
+  const rounded = Math.round(exact);
+  const drift = Math.abs(exact - rounded);
+  if (drift > driftTracker.max) driftTracker.max = drift;
+  return centsFromFloat(value, LEGACY_DRIFT_CENTS);
+}
+
+export async function migrateToV2(): Promise<IMigrationReport> {
+  const db = getDbSync();
+  const entries = db.mongoDb.collection(JOURNAL_ENTRY_COLLECTION);
+  const transactions = db.mongoDb.collection('Transaction');
+  const drift = { max: 0 };
+  const report: IMigrationReport = {
+    startedAt: new Date(),
+    finishedAt: null,
+    m001: { journalEntriesBackfilled: 0, transactionsBackfilled: 0, maxDriftCents: 0 },
+    m002: { legacyEntriesUpgraded: 0, transactionsSynthesized: 0 },
+    m003: [],
+  };
+
+  // ---------- M001: cents backfill on legacy journal entries ----------
+  const legacyEntries = await entries
+    .find({ schemaVersion: { $exists: false } })
+    .toArray();
+  for (const doc of legacyEntries) {
+    const lines = (doc.lines ?? []) as Array<Record<string, unknown>>;
+    const debitLines = lines.filter((line) => ((line.debit as number) ?? 0) > 0);
+    const creditLines = lines.filter((line) => ((line.credit as number) ?? 0) > 0);
+    const counterFor = (isDebit: boolean): string => {
+      const opposite = isDebit ? creditLines : debitLines;
+      return (opposite[0]?.accountNumber as string) ?? '';
+    };
+    const upgraded = lines.map((line) => {
+      const isDebit = ((line.debit as number) ?? 0) > 0;
+      const amount = isDebit ? (line.debit as number) : ((line.credit as number) ?? 0);
+      return {
+        ...line,
+        side: line.side ?? (isDebit ? 'debit' : 'credit'),
+        amountCents: line.amountCents ?? toCents(amount, drift),
+        counterAccount: line.counterAccount ?? counterFor(isDebit),
+        buKey: line.buKey ?? mapNumericPostingKey(line.postingKey as number),
+        buchungstext: line.buchungstext ?? line.description ?? doc.description,
+      };
+    });
+    await entries.updateOne({ _id: doc._id }, { $set: { lines: upgraded } });
+    report.m001.journalEntriesBackfilled++;
+  }
+
+  // cents mirrors on frozen legacy transactions (informational)
+  const legacyTransactions = await transactions
+    .find({ amountCents: { $exists: false } })
+    .toArray();
+  for (const doc of legacyTransactions) {
+    await transactions.updateOne(
+      { _id: doc._id },
+      {
+        $set: {
+          amountCents: toCents((doc.amount as number) ?? 0, drift),
+          vatAmountCents: toCents((doc.vatAmount as number) ?? 0, drift),
+        },
+      },
+    );
+    report.m001.transactionsBackfilled++;
+  }
+  report.m001.maxDriftCents = drift.max;
+
+  // ---------- M002: unify into the v2 journal ----------
+  // referenced transactions already live inside a journal entry
+  const referencedIds = new Set<string>();
+  const entryDocs = await entries.find({}).toArray();
+  for (const doc of entryDocs) {
+    for (const id of (doc.transactionIds as string[]) ?? []) referencedIds.add(id);
+  }
+
+  for (const doc of entryDocs) {
+    if (doc.schemaVersion === 2) continue;
+    await entries.updateOne(
+      { _id: doc._id },
+      {
+        $set: {
+          schemaVersion: 2,
+          currency: doc.currency ?? 'EUR',
+          legacyImport: true,
+          legacyStatus: doc.status,
+          status: doc.status === 'reversed' ? 'posted' : doc.status,
+        },
+      },
+    );
+    report.m002.legacyEntriesUpgraded++;
+  }
+
+  const standalone = await transactions
+    .find({ synthesizedIntoJournal: { $exists: false } })
+    .toArray();
+  for (const doc of standalone) {
+    if (referencedIds.has(doc.id as string)) continue;
+    const amountCents = (doc.amountCents as number) ?? toCents((doc.amount as number) ?? 0, drift);
+    const date = doc.date as Date;
+    const synthesized = {
+      id: plugins.smartunique.shortId(),
+      journalNumber: `JRN-LEGACY-${doc.transactionNumber ?? doc.id}`,
+      date,
+      description: (doc.description as string) ?? '',
+      reference: (doc.reference as string) ?? '',
+      skrType: doc.skrType as TSKRType,
+      currency: 'EUR',
+      schemaVersion: 2,
+      legacyImport: true,
+      legacyStatus: doc.status,
+      legacyTransactionId: doc.id,
+      status: doc.status === 'reversed' ? 'posted' : (doc.status as string),
+      period: doc.period as string,
+      fiscalYear: doc.fiscalYear as number,
+      createdAt: (doc.createdAt as Date) ?? date,
+      postedAt: (doc.postedAt as Date) ?? date,
+      createdBy: (doc.createdBy as string) ?? 'migration',
+      totalDebits: ((doc.amount as number) ?? 0),
+      totalCredits: ((doc.amount as number) ?? 0),
+      isBalanced: true,
+      transactionIds: [],
+      lines: [
+        {
+          accountNumber: doc.debitAccount as string,
+          debit: (doc.amount as number) ?? 0,
+          credit: 0,
+          description: (doc.description as string) ?? '',
+          side: 'debit',
+          amountCents,
+          counterAccount: doc.creditAccount as string,
+          buKey: '',
+          buchungstext: (doc.description as string) ?? '',
+          vatAmountCents: (doc.vatAmountCents as number) ?? 0,
+          costCenter1: (doc.costCenter as string) || undefined,
+        },
+        {
+          accountNumber: doc.creditAccount as string,
+          debit: 0,
+          credit: (doc.amount as number) ?? 0,
+          description: (doc.description as string) ?? '',
+          side: 'credit',
+          amountCents,
+          counterAccount: doc.debitAccount as string,
+          buKey: '',
+          buchungstext: (doc.description as string) ?? '',
+        },
+      ],
+    };
+    await entries.insertOne(synthesized as never);
+    await transactions.updateOne(
+      { _id: doc._id },
+      { $set: { synthesizedIntoJournal: synthesized.id } },
+    );
+    report.m002.transactionsSynthesized++;
+  }
+
+  // ---------- M003: append unchained entries to the hash chain ----------
+  const unchained = await entries
+    .find({ schemaVersion: 2, sequenceNumber: { $exists: false } })
+    .toArray();
+  const groups = new Map<string, typeof unchained>();
+  for (const doc of unchained) {
+    const key = `${doc.skrType}:${doc.fiscalYear}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key)!.push(doc);
+  }
+
+  const sequences = db.mongoDb.collection('LedgerSequence');
+  for (const [key, docs] of groups) {
+    const [skrType, yearString] = key.split(':');
+    const fiscalYear = Number.parseInt(yearString, 10);
+    docs.sort((a, b) => {
+      const timeA = ((a.postedAt ?? a.createdAt ?? a.date) as Date).getTime();
+      const timeB = ((b.postedAt ?? b.createdAt ?? b.date) as Date).getTime();
+      if (timeA !== timeB) return timeA - timeB;
+      return String(a.id).localeCompare(String(b.id));
+    });
+
+    const state = await sequences.findOne({ skrType, fiscalYear });
+    let sequenceNumber = (state?.value as number) ?? 0;
+    let headHash = (state?.headHash as string) ?? core.genesisHash(skrType, fiscalYear);
+
+    for (const doc of docs) {
+      sequenceNumber += 1;
+      const postedAt = (doc.postedAt ?? doc.createdAt ?? doc.date) as Date;
+      const entryHash = core.entryHash(
+        headHash,
+        buildHashPayload({
+          sequenceNumber,
+          skrType,
+          fiscalYear,
+          date: doc.date as Date,
+          postedAt,
+          description: doc.description as string,
+          reference: doc.reference as string,
+          taxScenario: doc.taxScenario as string,
+          currency: (doc.currency as string) ?? 'EUR',
+          reversalOf: doc.reversalOf as string,
+          lines: (doc.lines ?? []) as never[],
+        }),
+      );
+      await entries.updateOne(
+        { _id: doc._id },
+        { $set: { sequenceNumber, prevHash: headHash, entryHash, postedAt } },
+      );
+      headHash = entryHash;
+    }
+
+    await sequences.updateOne(
+      { skrType, fiscalYear },
+      { $set: { value: sequenceNumber, headHash } },
+      { upsert: true },
+    );
+    report.m003.push({ skrType, fiscalYear, chainedEntries: docs.length, headHash });
+  }
+
+  report.finishedAt = new Date();
+  return report;
+}

package/ts/skr.period.ts

@@ -0,0 +1,139 @@
+/**
+ * Accounting period locks (Festschreibung). One document per
+ * (skrType, period 'YYYY-MM') in the LedgerPeriod collection.
+ *
+ * festschreibePeriod() stamps all posted schemaVersion-2 entries of the
+ * period as finalized via a raw update — deliberately bypassing the doc-level
+ * immutability guard, because the finalization fields live OUTSIDE the entry
+ * hash. Detection of any other raw-driver tampering is verifyHashChain()'s job.
+ */
+import { getDbSync, type TDbSession } from './skr.database.js';
+import { PeriodLockedError } from './skr.errors.js';
+import { getSequenceState } from './skr.sequence.js';
+import type { TSKRType } from './skr.types.js';
+
+export const LEDGER_PERIOD_COLLECTION = 'LedgerPeriod';
+export const JOURNAL_ENTRY_COLLECTION = 'JournalEntry';
+
+export interface ILedgerPeriodState {
+  skrType: TSKRType;
+  period: string; // YYYY-MM
+  status: 'open' | 'locked';
+  lockedAt?: Date;
+  lockedBy?: string;
+  chainCheckpoint?: { lastSequenceNumber: number; headHash: string } | null;
+}
+
+function periodCollection() {
+  return getDbSync().mongoDb.collection(LEDGER_PERIOD_COLLECTION);
+}
+
+export async function ensurePeriodIndexes(): Promise<void> {
+  await periodCollection().createIndex({ skrType: 1, period: 1 }, { unique: true });
+}
+
+export function periodOf(date: Date): string {
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}`;
+}
+
+export function fiscalYearOf(date: Date): number {
+  return date.getUTCFullYear();
+}
+
+/**
+ * Throws PeriodLockedError when the period is festgeschrieben. Runs inside
+ * the posting transaction so a concurrent lock aborts the posting.
+ */
+export async function assertPeriodOpen(
+  skrType: TSKRType,
+  period: string,
+  session?: TDbSession,
+): Promise<void> {
+  const doc = await periodCollection().findOne({ skrType, period }, { session });
+  if (doc && doc.status === 'locked') {
+    throw new PeriodLockedError(skrType, period);
+  }
+}
+
+export async function getPeriodState(
+  skrType: TSKRType,
+  period: string,
+): Promise<ILedgerPeriodState | null> {
+  const doc = await periodCollection().findOne({ skrType, period });
+  if (!doc) return null;
+  return {
+    skrType,
+    period,
+    status: doc.status as 'open' | 'locked',
+    lockedAt: doc.lockedAt as Date | undefined,
+    lockedBy: doc.lockedBy as string | undefined,
+    chainCheckpoint: (doc.chainCheckpoint as ILedgerPeriodState['chainCheckpoint']) ?? null,
+  };
+}
+
+/**
+ * Festschreibung: lock the period against new postings and stamp all posted
+ * schemaVersion-2 entries as finalized. Idempotent — locking a locked period
+ * throws so callers notice double runs.
+ */
+export async function festschreibePeriod(params: {
+  skrType: TSKRType;
+  period: string;
+  lockedBy?: string;
+  lockedAt?: Date;
+}): Promise<{ finalizedEntries: number; checkpoint: ILedgerPeriodState['chainCheckpoint'] }> {
+  const db = getDbSync();
+  const session = db.startSession();
+  const lockedAt = params.lockedAt ?? new Date();
+  try {
+    let finalizedEntries = 0;
+    let checkpoint: ILedgerPeriodState['chainCheckpoint'] = null;
+    await session.withTransaction(async () => {
+      const existing = await periodCollection().findOne(
+        { skrType: params.skrType, period: params.period },
+        { session },
+      );
+      if (existing && existing.status === 'locked') {
+        throw new PeriodLockedError(params.skrType, params.period);
+      }
+
+      const stamp = await db.mongoDb.collection(JOURNAL_ENTRY_COLLECTION).updateMany(
+        {
+          skrType: params.skrType,
+          period: params.period,
+          schemaVersion: 2,
+          status: 'posted',
+        },
+        { $set: { status: 'finalized', finalizedAt: lockedAt } },
+        { session },
+      );
+      finalizedEntries = stamp.modifiedCount;
+
+      await periodCollection().updateOne(
+        { skrType: params.skrType, period: params.period },
+        {
+          $set: {
+            status: 'locked',
+            lockedAt,
+            lockedBy: params.lockedBy ?? 'system',
+          },
+        },
+        { upsert: true, session },
+      );
+    });
+
+    // checkpoint outside the txn: reads the settled chain head
+    const fiscalYear = Number.parseInt(params.period.slice(0, 4), 10);
+    const state = await getSequenceState(params.skrType, fiscalYear);
+    if (state) {
+      checkpoint = { lastSequenceNumber: state.value, headHash: state.headHash };
+      await periodCollection().updateOne(
+        { skrType: params.skrType, period: params.period },
+        { $set: { chainCheckpoint: checkpoint } },
+      );
+    }
+    return { finalizedEntries, checkpoint };
+  } finally {
+    await session.endSession();
+  }
+}

package/ts/skr.posting.ts

@@ -0,0 +1,273 @@
+/**
+ * JournalPoster — the atomic v2 posting path.
+ *
+ * Flow per posting: pure pre-flight validation (stateless core) → one MongoDB
+ * transaction containing period-lock re-check, gapless sequence allocation,
+ * hash computation, entry save, and a compare-and-swap on the chain head.
+ * The driver's withTransaction() retries transient conflicts; an abort rolls
+ * the sequence $inc back, so numbering stays gapless.
+ *
+ * JournalEntry (schemaVersion 2) is the single source of truth — no
+ * Transaction-pair explosion. Balances are aggregations (skr.balances.ts).
+ */
+import * as core from './core/index.js';
+import { getDbSync } from './skr.database.js';
+import { JournalEntry } from './skr.classes.journalentry.js';
+import { allocateSequence, advanceHead, ensureSequenceIndexes } from './skr.sequence.js';
+import {
+  assertPeriodOpen,
+  ensurePeriodIndexes,
+  fiscalYearOf,
+  periodOf,
+  JOURNAL_ENTRY_COLLECTION,
+} from './skr.period.js';
+import { PeriodLockedError, TransactionsUnsupportedError } from './skr.errors.js';
+import type { IJournalEntryLine } from './skr.types.js';
+
+export interface IPostDraftOptions {
+  policy?: core.IAccountPolicy;
+  postedAt?: Date;
+  createdBy?: string;
+}
+
+/**
+ * The exact structure whose canonical form is hashed into the chain.
+ * Built identically by the poster (from the draft) and the verifier (from the
+ * persisted document) — every optional is normalized so both sides match.
+ */
+export function buildHashPayload(entry: {
+  sequenceNumber: number;
+  skrType: string;
+  fiscalYear: number;
+  date: Date;
+  postedAt: Date;
+  description: string;
+  reference?: string | null;
+  taxScenario?: string | null;
+  currency?: string | null;
+  reversalOf?: string | null;
+  lines: Array<{
+    accountNumber: string;
+    counterAccount?: string | null;
+    side?: string | null;
+    amountCents?: number | null;
+    buKey?: string | null;
+    buchungstext?: string | null;
+    belegfeld1?: string | null;
+    costCenter1?: string | null;
+    docLink?: string | null;
+    vatAmountCents?: number | null;
+  }>;
+}): Record<string, unknown> {
+  return {
+    sequenceNumber: entry.sequenceNumber,
+    skrType: entry.skrType,
+    fiscalYear: entry.fiscalYear,
+    date: entry.date,
+    postedAt: entry.postedAt,
+    description: entry.description ?? '',
+    reference: entry.reference ?? '',
+    taxScenario: entry.taxScenario ?? '',
+    currency: entry.currency ?? 'EUR',
+    reversalOf: entry.reversalOf ?? '',
+    lines: entry.lines.map((line) => ({
+      accountNumber: line.accountNumber,
+      counterAccount: line.counterAccount ?? '',
+      side: line.side ?? '',
+      amountCents: line.amountCents ?? 0,
+      buKey: line.buKey ?? '',
+      buchungstext: line.buchungstext ?? '',
+      belegfeld1: line.belegfeld1 ?? '',
+      costCenter1: line.costCenter1 ?? '',
+      docLink: line.docLink ?? '',
+      vatAmountCents: line.vatAmountCents ?? 0,
+    })),
+  };
+}
+
+export class JournalPoster {
+  /**
+   * Create the indexes the v2 posting path relies on. Idempotent.
+   */
+  public async ensureIndexes(): Promise<void> {
+    await ensureSequenceIndexes();
+    await ensurePeriodIndexes();
+    await getDbSync()
+      .mongoDb.collection(JOURNAL_ENTRY_COLLECTION)
+      .createIndex(
+        { skrType: 1, fiscalYear: 1, sequenceNumber: 1 },
+        {
+          unique: true,
+          // only chained entries — migration inserts docs before sequencing
+          partialFilterExpression: {
+            schemaVersion: 2,
+            sequenceNumber: { $exists: true },
+          },
+        },
+      );
+  }
+
+  /**
+   * Probe transaction support with a no-op transaction. Fails hard —
+   * filing-grade posting has no non-transactional fallback.
+   */
+  public async assertTransactionSupport(): Promise<void> {
+    const db = getDbSync();
+    const session = db.startSession();
+    try {
+      await session.withTransaction(async () => {
+        await db.mongoDb
+          .collection(JOURNAL_ENTRY_COLLECTION)
+          .findOne({ _id: 'txn-probe' as never }, { session });
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new TransactionsUnsupportedError(message);
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  /**
+   * Validate and atomically post a journal draft. Returns the persisted,
+   * hashed, immutable JournalEntry.
+   */
+  public async postDraft(
+    draft: core.IJournalDraft,
+    options?: IPostDraftOptions,
+  ): Promise<JournalEntry> {
+    const validation = core.validateJournalDraft(draft, options?.policy);
+    if (!validation.valid) {
+      throw new Error(`Journal draft invalid: ${validation.errors.join('; ')}`);
+    }
+    const normalized = validation.normalized;
+    const period = periodOf(normalized.date);
+    const fiscalYear = fiscalYearOf(normalized.date);
+    const postedAt = options?.postedAt ?? new Date();
+
+    const db = getDbSync();
+    const session = db.startSession();
+    try {
+      let posted: JournalEntry | null = null;
+      await session.withTransaction(async () => {
+        await assertPeriodOpen(normalized.skrType, period, session);
+
+        const { sequenceNumber, prevHash } = await allocateSequence(
+          normalized.skrType,
+          fiscalYear,
+          session,
+        );
+
+        const lines: IJournalEntryLine[] = normalized.lines.map((line) => ({
+          accountNumber: line.accountNumber,
+          // legacy float mirrors keep v1 reports readable during migration
+          debit: line.side === 'debit' ? line.amountCents / 100 : 0,
+          credit: line.side === 'credit' ? line.amountCents / 100 : 0,
+          description: line.buchungstext,
+          side: line.side,
+          amountCents: line.amountCents,
+          counterAccount: line.counterAccount,
+          buKey: line.buKey,
+          buchungstext: line.buchungstext,
+          belegfeld1: line.belegfeld1,
+          costCenter1: line.costCenter1,
+          docLink: line.docLink,
+          vatAmountCents: line.vatAmountCents,
+        }));
+
+        const entry = new JournalEntry({
+          date: normalized.date,
+          description: normalized.description,
+          reference: normalized.reference,
+          skrType: normalized.skrType,
+          lines,
+        });
+        entry.schemaVersion = 2;
+        entry.sequenceNumber = sequenceNumber;
+        entry.prevHash = prevHash;
+        entry.taxScenario = normalized.taxScenario;
+        entry.currency = normalized.currency;
+        entry.reversalOf = normalized.reversalOf;
+        entry.status = 'posted';
+        entry.postedAt = postedAt;
+        entry.finalizedAt = null;
+        entry.createdBy = options?.createdBy ?? 'system';
+        // period/fiscalYear are UTC-derived here; the constructor derives them
+        // from local time, so overwrite for determinism
+        entry.period = period;
+        entry.fiscalYear = fiscalYear;
+
+        entry.entryHash = core.entryHash(
+          prevHash,
+          buildHashPayload({
+            sequenceNumber,
+            skrType: normalized.skrType,
+            fiscalYear,
+            date: normalized.date,
+            postedAt,
+            description: normalized.description,
+            reference: normalized.reference,
+            taxScenario: normalized.taxScenario,
+            currency: normalized.currency,
+            reversalOf: normalized.reversalOf,
+            lines,
+          }),
+        );
+
+        await entry.save({ session });
+        await advanceHead(
+          normalized.skrType,
+          fiscalYear,
+          prevHash,
+          entry.entryHash,
+          session,
+        );
+        posted = entry;
+      });
+      if (!posted) {
+        throw new Error('Posting transaction did not complete');
+      }
+      return posted;
+    } catch (error) {
+      if (error instanceof PeriodLockedError) throw error;
+      throw error;
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  /**
+   * Storno: post a reversal entry for a hashed entry WITHOUT mutating the
+   * original (GoBD). The reversal references the original via belegfeld1 and
+   * reference; reversal state is derived by querying, never stored on the
+   * original.
+   */
+  public async postStorno(
+    original: JournalEntry,
+    options?: IPostDraftOptions & { date?: Date; description?: string },
+  ): Promise<JournalEntry> {
+    if (original.schemaVersion !== 2 || !original.entryHash) {
+      throw new Error('postStorno only reverses schemaVersion-2 (hashed) entries');
+    }
+    const draft: core.IJournalDraft = {
+      date: options?.date ?? new Date(),
+      description:
+        options?.description ?? `Storno ${original.journalNumber}: ${original.description}`,
+      reference: `STORNO-${original.journalNumber}`,
+      skrType: original.skrType,
+      reversalOf: original.id,
+      currency: (original.currency as 'EUR') ?? 'EUR',
+      taxScenario: original.taxScenario as core.TTaxScenario | undefined,
+      lines: original.lines.map((line) => ({
+        accountNumber: line.accountNumber,
+        counterAccount: line.counterAccount ?? '',
+        side: line.side === 'debit' ? 'credit' : 'debit',
+        amountCents: line.amountCents ?? 0,
+        buKey: (line.buKey ?? '') as core.TBuKey,
+        buchungstext: `Storno: ${line.buchungstext ?? ''}`,
+        belegfeld1: original.journalNumber,
+      })),
+    };
+    return this.postDraft(draft, options);
+  }
+}