@kreiseck/kasseneck-api 0.31.0 → 1.0.0-rc.2

package/dist/{cjs/rechnung → esm/invoice}/api.d.ts

@@ -6,49 +6,50 @@
  */
 import { type FetchLike } from '../client/transport.js';
 import type { EInvoiceFormat, InvoiceLanguage } from './vertrag.js';
-import type { Brand, CancelInvoiceRequest, CancelResult, CreditNoteRequest, CreditNoteResult, Customer, CustomerInput, CustomerPage, CustomerSearch, InvoiceDetail, InvoiceListQuery, InvoicePage, InvoiceSetupStatus, IssueInvoiceRequest, IssueResult, PreviewResult, RecordPaymentRequest, RecordPaymentResult } from './typen.js';
-export interface RechnungApiOptions {
+import type { Brand, CancelInvoiceRequest, CancelResult, CreditNoteRequest, CreditNoteResult, Customer, CustomerInput, CustomerPage, CustomerSearch, InvoiceDetail, InvoiceListQuery, InvoicePage, InvoiceSetupStatus, InvoiceXml, IssueInvoiceRequest, IssueResult, PreviewResult, RecordPaymentRequest, RecordPaymentResult } from './typen.js';
+export interface InvoiceApiOptions {
     /** `api_key` des Kontos (`kr_live_…` / `kr_test_…`). Gehoert auf einen Server. */
     apiKey: string;
-    /** Abweichende Basis-URL; Vorgabe `https://api.kasseneck.at/v1`. */
+    /** Abweichende Basis-URL; Vorgabe `https://api.kasseneck.at/v3`. */
     baseUrl?: string;
     /** Zeitlimit je Aufruf in Millisekunden. */
     timeoutMs?: number;
     /** Eigene `fetch`-Umsetzung (Tests, Proxys). */
     fetch?: FetchLike;
 }
-export interface RechnungApi {
-    createCustomer(customer: CustomerInput, optionen?: {
+export interface InvoiceApi {
+    createCustomer(customer: CustomerInput, options?: {
         idempotencyKey?: string;
     }): Promise<Customer>;
-    getCustomer(kennung: {
+    getCustomer(ref: {
         customerId: string;
     } | {
         externalId: string;
     }): Promise<Customer>;
     updateCustomer(customerId: string, patch: Partial<CustomerInput>): Promise<Customer>;
-    searchCustomers(suche: CustomerSearch): Promise<CustomerPage>;
-    issueInvoice(anfrage: IssueInvoiceRequest): Promise<IssueResult>;
+    searchCustomers(search: CustomerSearch): Promise<CustomerPage>;
+    issueInvoice(request: IssueInvoiceRequest): Promise<IssueResult>;
     /** Probelauf: pruefen und rechnen wie `issueInvoice`, ohne auszustellen. */
-    previewInvoice(anfrage: IssueInvoiceRequest): Promise<PreviewResult>;
-    cancelInvoice(anfrage: CancelInvoiceRequest): Promise<CancelResult>;
-    createCreditNote(anfrage: CreditNoteRequest): Promise<CreditNoteResult>;
-    getInvoice(kennung: {
+    previewInvoice(request: IssueInvoiceRequest): Promise<PreviewResult>;
+    cancelInvoice(request: CancelInvoiceRequest): Promise<CancelResult>;
+    createCreditNote(request: CreditNoteRequest): Promise<CreditNoteResult>;
+    getInvoice(ref: {
         invoiceId: string;
     } | {
         number: string;
     }): Promise<InvoiceDetail>;
-    listInvoices(abfrage?: InvoiceListQuery): Promise<InvoicePage>;
+    listInvoices(query?: InvoiceListQuery): Promise<InvoicePage>;
     /** Eine spaeter eingetroffene Zahlung nachtragen; `idempotencyKey` ist Pflicht. */
-    recordInvoicePayment(anfrage: RecordPaymentRequest): Promise<RecordPaymentResult>;
+    recordInvoicePayment(request: RecordPaymentRequest): Promise<RecordPaymentResult>;
     /** Mit `language` ungleich der Rechnungssprache: gekennzeichnete Uebersetzungskopie. */
-    getInvoicePdf(invoiceId: string, optionen?: {
+    getInvoicePdf(invoiceId: string, options?: {
         language?: InvoiceLanguage;
     }): Promise<Uint8Array>;
-    getInvoiceXml(invoiceId: string, format?: EInvoiceFormat): Promise<string>;
+    /** `{ xml, format, filename }` wie gesendet; `filename` ist `invoice-<Nummer>.xml`. */
+    getInvoiceXml(invoiceId: string, format?: EInvoiceFormat): Promise<InvoiceXml>;
     /** Darf dieses Konto ausstellen, und was fehlt noch? Laeuft auch ohne Freigabe. */
     getInvoiceSetupStatus(): Promise<InvoiceSetupStatus>;
     /** Die Marken des Kontos; `id` geht als `brandId` in `issueInvoice`. */
     listBrands(): Promise<Brand[]>;
 }
-export declare function createRechnungApi(optionen: RechnungApiOptions): RechnungApi;
+export declare function createInvoiceApi(options: InvoiceApiOptions): InvoiceApi;

package/dist/esm/{rechnung → invoice}/api.js

@@ -5,14 +5,14 @@
  * Funktionen (endpunkte.ts) und bleiben einzeln importierbar.
  */
 import { createBinaryTransport, createTransport } from '../client/transport.js';
-import { rechnungKeyAuth } from './auth.js';
+import { invoiceKeyAuth } from './auth.js';
 import { cancelInvoice, createCreditNote, createCustomer, getCustomer, getInvoice, getInvoicePdf, getInvoiceSetupStatus, getInvoiceXml, issueInvoice, listBrands, previewInvoice, listInvoices, recordInvoicePayment, searchCustomers, updateCustomer, } from './endpunkte.js';
-export function createRechnungApi(optionen) {
+export function createInvoiceApi(options) {
     const transportOptionen = {
-        auth: rechnungKeyAuth({ apiKey: optionen.apiKey }),
-        baseUrl: optionen.baseUrl,
-        timeoutMs: optionen.timeoutMs,
-        fetch: optionen.fetch,
+        auth: invoiceKeyAuth({ apiKey: options.apiKey }),
+        baseUrl: options.baseUrl,
+        timeoutMs: options.timeoutMs,
+        fetch: options.fetch,
     };
     const rufen = createTransport(transportOptionen);
     const rufenBinaer = createBinaryTransport(transportOptionen);

package/dist/{cjs/rechnung → esm/invoice}/auth.d.ts

@@ -14,8 +14,8 @@
  * weiterhin aeltere Formen annimmt. Die Meldung nennt nie den Wert, nur seine Art.
  */
 import type { KasseneckAuth } from '../client/auth.js';
-export interface RechnungKeyAuthOptions {
+export interface InvoiceKeyAuthOptions {
     /** `api_key` des Kontos, z. B. `kr_live_…` oder `kr_test_…`. */
     apiKey: string;
 }
-export declare function rechnungKeyAuth(options: RechnungKeyAuthOptions): KasseneckAuth;
+export declare function invoiceKeyAuth(options: InvoiceKeyAuthOptions): KasseneckAuth;

package/dist/esm/{rechnung → invoice}/auth.js

@@ -14,16 +14,16 @@
  * weiterhin aeltere Formen annimmt. Die Meldung nennt nie den Wert, nur seine Art.
  */
 import { KasseneckAuthError } from '../client/errors.js';
-export function rechnungKeyAuth(options) {
+export function invoiceKeyAuth(options) {
     const schluessel = typeof options?.apiKey === 'string' ? options.apiKey.trim() : '';
     if (!schluessel) {
-        throw new KasseneckAuthError('rechnungKeyAuth: apiKey fehlt');
+        throw new KasseneckAuthError('invoiceKeyAuth: apiKey fehlt');
     }
     if (/^pk_(live|test)_/i.test(schluessel)) {
-        throw new KasseneckAuthError('rechnungKeyAuth: das ist ein Partner-Schluessel (pk_…) — die Rechnungs-API nimmt den api_key des Kontos (kr_…)');
+        throw new KasseneckAuthError('invoiceKeyAuth: das ist ein Partner-Schluessel (pk_…); die Rechnungs-API nimmt den api_key des Kontos (kr_…)');
     }
     if (/^cb_(live|test)_/i.test(schluessel)) {
-        throw new KasseneckAuthError('rechnungKeyAuth: das ist ein Kassen-Token (cb_…) — die Rechnungs-API nimmt den api_key des Kontos (kr_…)');
+        throw new KasseneckAuthError('invoiceKeyAuth: das ist ein Kassen-Token (cb_…); die Rechnungs-API nimmt den api_key des Kontos (kr_…)');
     }
     // Pro Aufruf ein frisches Objekt, wie bei den anderen Anmeldungen.
     return () => ({

package/dist/{cjs/rechnung/rechnen.d.ts → esm/invoice/calc.d.ts}

@@ -20,11 +20,11 @@
  */
 import type { PriceMode, TaxScheme } from './vertrag.js';
 /** Hoechster Betrag je Zeile und je Rechnung: 999.999.999,99 €. */
-export declare const BETRAG_GRENZE_CENTS = 99999999999;
+export declare const MAX_AMOUNT_CENTS = 99999999999;
 /** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
-export declare const STEUERFREIE_FAELLE: readonly TaxScheme[];
+export declare const ZERO_RATED_TAX_SCHEMES: readonly TaxScheme[];
 /** Eine Position in gespeicherter Form — alle Werte ganzzahlig. */
-export interface RechenPosition {
+export interface CalcItem {
     /** Einzelpreis in Millionstel Euro, 0 … 10¹². */
     unitPriceMicros: number;
     /** Menge in Tausendstel; negativ = Abzugszeile, 0 = Textzeile. */
@@ -34,39 +34,39 @@ export interface RechenPosition {
     /** USt-Satz in Hundertstel-Prozent, 0 … 10000 (ohne Angabe 0). */
     vatRateBp?: number;
 }
-export interface RechenOptionen {
+export interface CalcOptions {
     priceMode: PriceMode;
     /** Ohne Angabe `normal`. */
     taxScheme?: TaxScheme;
 }
-export interface SatzSumme {
+export interface RateTotal {
     rateBp: number;
     netCents: number;
     vatCents: number;
     grossCents: number;
 }
-export interface ZeilenBetrag {
+export interface LineAmount {
     netCents: number;
     grossCents: number;
     /** Der Satz, mit dem die Zeile gerechnet wurde (bei steuerfreiem Fall 0). */
     rateBp: number;
 }
-export interface RechenErgebnis {
+export interface CalcResult {
     netCents: number;
     vatCents: number;
     grossCents: number;
     /** Absteigend nach `rateBp`. */
-    byRate: SatzSumme[];
+    byRate: RateTotal[];
     /** Je Position, in der Reihenfolge der Eingabe. */
-    lines: ZeilenBetrag[];
+    lines: LineAmount[];
 }
-export type RechenFehlerCode = 'amount_too_large' | 'kein_ganzzahlwert' | 'ausserhalb';
+export type CalcErrorCode = 'amount_too_large' | 'not_integer' | 'out_of_range';
 /** Fehler des Kerns — mit Code, Feld und Index, damit die API daraus einen Feldfehler machen kann. */
-export declare class RechenFehler extends Error {
-    readonly code: RechenFehlerCode;
-    readonly feld?: string;
+export declare class CalcError extends Error {
+    readonly code: CalcErrorCode;
+    readonly field?: string;
     readonly index?: number;
-    constructor(code: RechenFehlerCode, nachricht: string, feld?: string, index?: number);
+    constructor(code: CalcErrorCode, message: string, field?: string, index?: number);
 }
 /**
  * `a / b` kaufmaennisch gerundet, halbe Einheit vom Nullpunkt weg; `b` > 0.
@@ -74,16 +74,16 @@ export declare class RechenFehler extends Error {
  * Ohne Gleitkomma: `(2·|a| + b) / (2·b)` ist genau dann eins groesser, wenn der
  * Rest mindestens die halbe Einheit betraegt.
  */
-export declare function rund(a: bigint, b: bigint): bigint;
-export declare function rechnungRechnen(positionen: readonly RechenPosition[], optionen: RechenOptionen): RechenErgebnis;
-export type UmwandlungsGrund = 'kein_zahlwert' | 'nachkommastellen' | 'ausserhalb';
-export type Umwandlung = {
+export declare function roundDiv(a: bigint, b: bigint): bigint;
+export declare function calculateInvoice(items: readonly CalcItem[], options: CalcOptions): CalcResult;
+export type ConversionReason = 'not_a_number' | 'too_many_decimals' | 'out_of_range';
+export type ItemConversion = {
     ok: true;
-    position: RechenPosition & Record<string, unknown>;
+    item: CalcItem & Record<string, unknown>;
 } | {
     ok: false;
-    feld: 'unitPrice' | 'quantity' | 'vatRate' | 'discountPct';
-    grund: UmwandlungsGrund;
+    field: 'unitPrice' | 'quantity' | 'vatRate' | 'discountPct';
+    reason: ConversionReason;
 };
 /**
  * Euro-Position → Ganzzahl-Form, verlustfrei oder mit Grund abgelehnt. Die
@@ -98,26 +98,26 @@ export type Umwandlung = {
  * abgerechnet hat. Ein fehlender Preis dagegen ist NIE 0: sonst wuerde eine
  * Position, der nur der Preis fehlt, still zur 0-€-Zeile.
  */
-export declare function positionAusEuro(item: Record<string, unknown>): Umwandlung;
+export declare function itemFromEuro(item: Record<string, unknown>): ItemConversion;
 /**
  * Anteiliger Preis fuer einen Teilzeitraum (erste Rechnung eines Abos).
  * War der Ursprungspreis centgenau, bleibt auch der Anteil centgenau — sonst
  * stuende auf der ersten Rechnung ein Preis mit sechs Stellen, wo bisher zwei
  * standen.
  */
-export declare function anteiligerPreis(unitPriceMicros: number, monate: number, intervall: number): number;
+export declare function proratedPriceMicros(unitPriceMicros: number, months: number, interval: number): number;
 /**
  * Schluessel eines USt-Satzes in den gespeicherten Maps (`creditedCents.byRate`,
  * `invoice_stats.vatByRate`): der Prozenttext mit Punkt, genau wie
  * `String(satz)` ihn bisher gebildet hat. NICHT fuer die Anzeige — dafuer gibt
- * es `satzText`.
+ * es `formatVatRate`.
  */
-export declare function satzSchluessel(rateBp: number): string;
+export declare function vatRateMapKey(rateBp: number): string;
 /** Ein USt-Satz fuer die Anzeige: oesterreichisch mit Komma, ohne nachlaufende Nullen. */
-export declare function satzText(rateBp: number): string;
+export declare function formatVatRate(rateBp: number): string;
 /**
  * Ein Einzelpreis fuer die Anzeige: mindestens zwei, hoechstens sechs
  * Nachkommastellen, Tausenderpunkt, Komma als Trennzeichen — in jeder Sprache
  * oesterreichisch, wie die Betraege auf dem Blatt.
  */
-export declare function preisText(unitPriceMicros: number): string;
+export declare function formatUnitPrice(unitPriceMicros: number): string;

package/dist/esm/{rechnung/rechnen.js → invoice/calc.js}

@@ -21,26 +21,26 @@
 /** Skala des Zeilenbruchs: 10⁻¹⁷ Cent. */
 const E = 10n ** 17n;
 /** Hoechster Betrag je Zeile und je Rechnung: 999.999.999,99 €. */
-export const BETRAG_GRENZE_CENTS = 99_999_999_999;
+export const MAX_AMOUNT_CENTS = 99_999_999_999;
 /** Steuerfaelle, in denen die Rechnung keine Steuer ausweist: jede Zeile zaehlt zu 0 %. */
-export const STEUERFREIE_FAELLE = Object.freeze([
+export const ZERO_RATED_TAX_SCHEMES = Object.freeze([
     'smallBusiness',
     'reverseCharge',
-    'igLieferung',
+    'intraCommunitySupply',
     'exportThirdCountry',
     'domesticReverseCharge',
     'outsideScope',
 ]);
 /** Fehler des Kerns — mit Code, Feld und Index, damit die API daraus einen Feldfehler machen kann. */
-export class RechenFehler extends Error {
+export class CalcError extends Error {
     code;
-    feld;
+    field;
     index;
-    constructor(code, nachricht, feld, index) {
-        super(nachricht);
-        this.name = 'RechenFehler';
+    constructor(code, message, field, index) {
+        super(message);
+        this.name = 'CalcError';
         this.code = code;
-        this.feld = feld;
+        this.field = field;
         this.index = index;
     }
 }
@@ -50,7 +50,7 @@ export class RechenFehler extends Error {
  * Ohne Gleitkomma: `(2·|a| + b) / (2·b)` ist genau dann eins groesser, wenn der
  * Rest mindestens die halbe Einheit betraegt.
  */
-export function rund(a, b) {
+export function roundDiv(a, b) {
     const negativ = a < 0n;
     const betrag = negativ ? -a : a;
     const ganz = (2n * betrag + b) / (2n * b);
@@ -64,11 +64,11 @@ const GRENZEN = {
 };
 function ganzzahl(wert, feld, index) {
     if (typeof wert !== 'number' || !Number.isInteger(wert)) {
-        throw new RechenFehler('kein_ganzzahlwert', `items[${index}].${feld} muss eine ganze Zahl sein`, feld, index);
+        throw new CalcError('not_integer', `items[${index}].${feld} muss eine ganze Zahl sein`, feld, index);
     }
     const [min, max] = GRENZEN[feld];
     if (wert < min || wert > max) {
-        throw new RechenFehler('ausserhalb', `items[${index}].${feld} liegt ausserhalb von ${min} … ${max}`, feld, index);
+        throw new CalcError('out_of_range', `items[${index}].${feld} liegt ausserhalb von ${min} … ${max}`, feld, index);
     }
     return wert;
 }
@@ -84,7 +84,7 @@ function ganzzahl(wert, feld, index) {
 function verteile(gruppe, feld, faktor, nenner, ziel) {
     const werte = gruppe.map((z) => {
         const zaehler = z.L * faktor;
-        return { z, zaehler, wert: rund(zaehler, nenner) };
+        return { z, zaehler, wert: roundDiv(zaehler, nenner) };
     });
     let rest = ziel - werte.reduce((s, w) => s + w.wert, 0n);
     if (rest !== 0n) {
@@ -106,18 +106,18 @@ function verteile(gruppe, feld, faktor, nenner, ziel) {
     for (const w of werte)
         w.z[feld] = Number(w.wert);
 }
-export function rechnungRechnen(positionen, optionen) {
-    const steuerfrei = STEUERFREIE_FAELLE.includes(optionen.taxScheme ?? 'normal');
-    const bruttoPreise = optionen.priceMode === 'gross' && !steuerfrei;
-    const grenze = BigInt(BETRAG_GRENZE_CENTS) * E;
-    const zeilen = positionen.map((p, index) => {
+export function calculateInvoice(items, options) {
+    const steuerfrei = ZERO_RATED_TAX_SCHEMES.includes(options.taxScheme ?? 'normal');
+    const bruttoPreise = options.priceMode === 'gross' && !steuerfrei;
+    const grenze = BigInt(MAX_AMOUNT_CENTS) * E;
+    const zeilen = items.map((p, index) => {
         const preis = BigInt(ganzzahl(p.unitPriceMicros, 'unitPriceMicros', index));
         const menge = BigInt(ganzzahl(p.quantityMilli, 'quantityMilli', index));
         const rabatt = BigInt(ganzzahl(p.discountBp ?? 0, 'discountBp', index));
         const satz = ganzzahl(p.vatRateBp ?? 0, 'vatRateBp', index);
         const L = preis * menge * (10000n - rabatt) * 1000000n;
         if ((L < 0n ? -L : L) > grenze) {
-            throw new RechenFehler('amount_too_large', `items[${index}] uebersteigt ${BETRAG_GRENZE_CENTS} Cent`, 'unitPriceMicros', index);
+            throw new CalcError('amount_too_large', `items[${index}] uebersteigt ${MAX_AMOUNT_CENTS} Cent`, 'unitPriceMicros', index);
         }
         return { index, rateBp: steuerfrei ? 0 : satz, L, netCents: 0, grossCents: 0 };
     });
@@ -137,13 +137,13 @@ export function rechnungRechnen(positionen, optionen) {
         let vatCents;
         let grossCents;
         if (bruttoPreise) {
-            grossCents = rund(S, E);
-            netCents = rund(grossCents * 10000n, 10000n + r);
+            grossCents = roundDiv(S, E);
+            netCents = roundDiv(grossCents * 10000n, 10000n + r);
             vatCents = grossCents - netCents;
         }
         else {
-            netCents = rund(S, E);
-            vatCents = rund(S * r, E * 10000n);
+            netCents = roundDiv(S, E);
+            vatCents = roundDiv(S * r, E * 10000n);
             grossCents = netCents + vatCents;
         }
         if (bruttoPreise) {
@@ -171,8 +171,8 @@ export function rechnungRechnen(positionen, optionen) {
         lines: zeilen.map((z) => ({ netCents: z.netCents, grossCents: z.grossCents, rateBp: z.rateBp })),
     };
     for (const feld of ['netCents', 'vatCents', 'grossCents']) {
-        if (Math.abs(ergebnis[feld]) > BETRAG_GRENZE_CENTS) {
-            throw new RechenFehler('amount_too_large', `Die Rechnung uebersteigt ${BETRAG_GRENZE_CENTS} Cent (${feld})`);
+        if (Math.abs(ergebnis[feld]) > MAX_AMOUNT_CENTS) {
+            throw new CalcError('amount_too_large', `Die Rechnung uebersteigt ${MAX_AMOUNT_CENTS} Cent (${feld})`);
         }
     }
     return ergebnis;
@@ -224,47 +224,47 @@ const EURO_FELDER = ['unitPrice', 'quantity', 'vatRate', 'discountPct'];
  * abgerechnet hat. Ein fehlender Preis dagegen ist NIE 0: sonst wuerde eine
  * Position, der nur der Preis fehlt, still zur 0-€-Zeile.
  */
-export function positionAusEuro(item) {
+export function itemFromEuro(item) {
     if (typeof item.unitPriceMicros === 'number') {
-        return { ok: true, position: item };
+        return { ok: true, item: item };
     }
     const roh = item.unitPrice;
     if (typeof roh !== 'number' || !Number.isFinite(roh)) {
-        return { ok: false, feld: 'unitPrice', grund: 'kein_zahlwert' };
+        return { ok: false, field: 'unitPrice', reason: 'not_a_number' };
     }
     const micros = ganzAusDezimaltext(Math.abs(roh), 6);
     if (micros === null)
-        return { ok: false, feld: 'unitPrice', grund: 'nachkommastellen' };
+        return { ok: false, field: 'unitPrice', reason: 'too_many_decimals' };
     if (micros > GRENZEN.unitPriceMicros[1])
-        return { ok: false, feld: 'unitPrice', grund: 'ausserhalb' };
+        return { ok: false, field: 'unitPrice', reason: 'out_of_range' };
     const zahl = (feld, stellen, max) => {
         const w = item[feld];
         if (w === undefined || w === null)
             return { ok: true, wert: 0 };
         if (typeof w !== 'number' || !Number.isFinite(w))
-            return { ok: false, grund: 'kein_zahlwert' };
+            return { ok: false, grund: 'not_a_number' };
         const ganz = ganzAusDezimaltext(w, stellen);
         if (ganz === null)
-            return { ok: false, grund: 'nachkommastellen' };
+            return { ok: false, grund: 'too_many_decimals' };
         if (ganz < (feld === 'quantity' ? -max : 0) || ganz > max)
-            return { ok: false, grund: 'ausserhalb' };
+            return { ok: false, grund: 'out_of_range' };
         return { ok: true, wert: ganz };
     };
     const menge = zahl('quantity', 3, GRENZEN.quantityMilli[1]);
     if (!menge.ok)
-        return { ok: false, feld: 'quantity', grund: menge.grund };
+        return { ok: false, field: 'quantity', reason: menge.grund };
     const satz = zahl('vatRate', 2, 10_000);
     if (!satz.ok)
-        return { ok: false, feld: 'vatRate', grund: satz.grund };
+        return { ok: false, field: 'vatRate', reason: satz.grund };
     const rabatt = zahl('discountPct', 2, 10_000);
     if (!rabatt.ok)
-        return { ok: false, feld: 'discountPct', grund: rabatt.grund };
+        return { ok: false, field: 'discountPct', reason: rabatt.grund };
     const rest = { ...item };
     for (const feld of EURO_FELDER)
         delete rest[feld];
     return {
         ok: true,
-        position: {
+        item: {
             ...rest,
             unitPriceMicros: micros,
             quantityMilli: roh < 0 ? -menge.wert : menge.wert,
@@ -279,32 +279,32 @@ export function positionAusEuro(item) {
  * stuende auf der ersten Rechnung ein Preis mit sechs Stellen, wo bisher zwei
  * standen.
  */
-export function anteiligerPreis(unitPriceMicros, monate, intervall) {
+export function proratedPriceMicros(unitPriceMicros, months, interval) {
     const micros = BigInt(unitPriceMicros);
-    const anteil = rund(micros * BigInt(monate), BigInt(intervall));
+    const anteil = roundDiv(micros * BigInt(months), BigInt(interval));
     if (unitPriceMicros % 10_000 !== 0)
         return Number(anteil);
-    return Number(rund(anteil, 10000n) * 10000n);
+    return Number(roundDiv(anteil, 10000n) * 10000n);
 }
 /**
  * Schluessel eines USt-Satzes in den gespeicherten Maps (`creditedCents.byRate`,
  * `invoice_stats.vatByRate`): der Prozenttext mit Punkt, genau wie
  * `String(satz)` ihn bisher gebildet hat. NICHT fuer die Anzeige — dafuer gibt
- * es `satzText`.
+ * es `formatVatRate`.
  */
-export function satzSchluessel(rateBp) {
+export function vatRateMapKey(rateBp) {
     return String(rateBp / 100);
 }
 /** Ein USt-Satz fuer die Anzeige: oesterreichisch mit Komma, ohne nachlaufende Nullen. */
-export function satzText(rateBp) {
-    return satzSchluessel(rateBp).replace('.', ',');
+export function formatVatRate(rateBp) {
+    return vatRateMapKey(rateBp).replace('.', ',');
 }
 /**
  * Ein Einzelpreis fuer die Anzeige: mindestens zwei, hoechstens sechs
  * Nachkommastellen, Tausenderpunkt, Komma als Trennzeichen — in jeder Sprache
  * oesterreichisch, wie die Betraege auf dem Blatt.
  */
-export function preisText(unitPriceMicros) {
+export function formatUnitPrice(unitPriceMicros) {
     const negativ = unitPriceMicros < 0;
     const betrag = Math.abs(unitPriceMicros);
     const ganz = Math.trunc(betrag / 1_000_000);

package/dist/{cjs/rechnung → esm/invoice}/endpunkte.d.ts

@@ -2,7 +2,7 @@
  * Die Aufrufe der Rechnungs-API — Kunden, Rechnungen, Gutschriften, Dateien.
  *
  * Jede Funktion nimmt den Transport als ersten Parameter und ist einzeln
- * importierbar; die Fassade [createRechnungApi] bindet ihn nur einmal.
+ * importierbar; die Fassade [createInvoiceApi] bindet ihn nur einmal.
  *
  * **Geprueft wird hier nichts Fachliches.** Die Anfrage geht unveraendert an
  * das Backend, das sie gegen denselben Vertrag prueft (`vertrag.ts`) und einen
@@ -17,19 +17,19 @@
  * der Aufruf `KasseneckValidationError` mit `scope:'response'`.
  */
 import type { InternerBinaerTransport, InternerTransport } from '../client/aufrufe.js';
-import type { EInvoiceFormat, InvoiceLanguage } from './vertrag.js';
-import type { Brand, CancelInvoiceRequest, CancelResult, CreditNoteRequest, CreditNoteResult, Customer, CustomerInput, CustomerPage, CustomerSearch, InvoiceDetail, InvoiceListQuery, InvoicePage, InvoiceSetupStatus, IssueInvoiceRequest, IssueResult, PreviewResult, RecordPaymentRequest, RecordPaymentResult } from './typen.js';
-export declare function createCustomer(rufen: InternerTransport, customer: CustomerInput, optionen?: {
+import { type EInvoiceFormat, type InvoiceLanguage } from './vertrag.js';
+import type { Brand, CancelInvoiceRequest, CancelResult, CreditNoteRequest, CreditNoteResult, Customer, CustomerInput, CustomerPage, CustomerSearch, InvoiceDetail, InvoiceListQuery, InvoicePage, InvoiceSetupStatus, InvoiceXml, IssueInvoiceRequest, IssueResult, PreviewResult, RecordPaymentRequest, RecordPaymentResult } from './typen.js';
+export declare function createCustomer(transport: InternerTransport, customer: CustomerInput, options?: {
     idempotencyKey?: string;
 }): Promise<Customer>;
-export declare function getCustomer(rufen: InternerTransport, kennung: {
+export declare function getCustomer(transport: InternerTransport, ref: {
     customerId: string;
 } | {
     externalId: string;
 }): Promise<Customer>;
-export declare function updateCustomer(rufen: InternerTransport, customerId: string, patch: Partial<CustomerInput>): Promise<Customer>;
-export declare function searchCustomers(rufen: InternerTransport, suche: CustomerSearch): Promise<CustomerPage>;
-export declare function issueInvoice(rufen: InternerTransport, anfrage: IssueInvoiceRequest): Promise<IssueResult>;
+export declare function updateCustomer(transport: InternerTransport, customerId: string, patch: Partial<CustomerInput>): Promise<Customer>;
+export declare function searchCustomers(transport: InternerTransport, search: CustomerSearch): Promise<CustomerPage>;
+export declare function issueInvoice(transport: InternerTransport, request: IssueInvoiceRequest): Promise<IssueResult>;
 /**
  * Probelauf von `issueInvoice`: dieselbe Anfrage wird geprueft und gerechnet
  * wie beim Ausstellen, aber nichts festgeschrieben. Die Antwort nennt Summen,
@@ -40,28 +40,28 @@ export declare function issueInvoice(rufen: InternerTransport, anfrage: IssueInv
  * danach unveraendert ausstellen. Verbindlich ist das Ausstellen — zwischen
  * Probelauf und Ausstellen kann sich der Kunde oder das Konto aendern.
  */
-export declare function previewInvoice(rufen: InternerTransport, anfrage: IssueInvoiceRequest): Promise<PreviewResult>;
-export declare function cancelInvoice(rufen: InternerTransport, anfrage: CancelInvoiceRequest): Promise<CancelResult>;
-export declare function createCreditNote(rufen: InternerTransport, anfrage: CreditNoteRequest): Promise<CreditNoteResult>;
-export declare function getInvoice(rufen: InternerTransport, kennung: {
+export declare function previewInvoice(transport: InternerTransport, request: IssueInvoiceRequest): Promise<PreviewResult>;
+export declare function cancelInvoice(transport: InternerTransport, request: CancelInvoiceRequest): Promise<CancelResult>;
+export declare function createCreditNote(transport: InternerTransport, request: CreditNoteRequest): Promise<CreditNoteResult>;
+export declare function getInvoice(transport: InternerTransport, ref: {
     invoiceId: string;
 } | {
     number: string;
 }): Promise<InvoiceDetail>;
-export declare function listInvoices(rufen: InternerTransport, abfrage?: InvoiceListQuery): Promise<InvoicePage>;
+export declare function listInvoices(transport: InternerTransport, query?: InvoiceListQuery): Promise<InvoicePage>;
 /**
  * Darf dieses Konto ueber die API ausstellen, und was fehlt noch? Laeuft auch
  * ohne Freigabe und vor der Live-Freischaltung — genau dann braucht man die
  * Antwort. Vor dem ersten `issueInvoice` aufrufen und `missing` anzeigen.
  */
-export declare function getInvoiceSetupStatus(rufen: InternerTransport): Promise<InvoiceSetupStatus>;
+export declare function getInvoiceSetupStatus(transport: InternerTransport): Promise<InvoiceSetupStatus>;
 /**
  * Das PDF der Rechnung (bei Gutschriften: der Gutschrift), mit eingebetteter
  * Factur-X-Datei. Mit `language` in der anderen Sprache als der Rechnung kommt
  * eine **Uebersetzungskopie**: dieselbe Nummer, auf jeder Seite als Uebersetzung
  * gekennzeichnet, ohne eingebettete E-Rechnung — keine eigene Rechnung.
  */
-export declare function getInvoicePdf(rufenBinaer: InternerBinaerTransport, invoiceId: string, optionen?: {
+export declare function getInvoicePdf(binaryTransport: InternerBinaerTransport, invoiceId: string, options?: {
     language?: InvoiceLanguage;
 }): Promise<Uint8Array>;
 /**
@@ -73,12 +73,14 @@ export declare function getInvoicePdf(rufenBinaer: InternerBinaerTransport, invo
  * zusaetzlich `notice` — eine Barzahlung ist ein Barumsatz und braucht einen
  * Beleg (§ 132a BAO), den dieser Vermerk nicht ersetzt.
  */
-export declare function recordInvoicePayment(rufen: InternerTransport, anfrage: RecordPaymentRequest): Promise<RecordPaymentResult>;
+export declare function recordInvoicePayment(transport: InternerTransport, request: RecordPaymentRequest): Promise<RecordPaymentResult>;
 /** Die Marken des Kontos — die Kennung geht als `brandId` in `issueInvoice`. */
-export declare function listBrands(rufen: InternerTransport): Promise<Brand[]>;
+export declare function listBrands(transport: InternerTransport): Promise<Brand[]>;
 /**
- * Die E-Rechnung als XML-Text. Sie kommt im gewohnten Umschlag (`data.xml`)
- * und nicht als rohe Datei: so bleibt ein fachlicher Fehler
- * (`einvoice_incomplete` mit `missing[]`) ein gewoehnlicher Fehler.
+ * Die E-Rechnung samt Format und Dateiname, genau wie der Server sie schickt.
+ * Sie kommt im gewohnten Umschlag (`data.xml`) und nicht als rohe Datei: so
+ * bleibt ein fachlicher Fehler (`einvoice_incomplete` mit `missing[]`) ein
+ * gewoehnlicher Fehler. Den Dateinamen nicht selbst bauen, sondern
+ * `filename` nehmen (`invoice-<Nummer>.xml`).
  */
-export declare function getInvoiceXml(rufen: InternerTransport, invoiceId: string, format?: EInvoiceFormat): Promise<string>;
+export declare function getInvoiceXml(transport: InternerTransport, invoiceId: string, format?: EInvoiceFormat): Promise<InvoiceXml>;