/**
 * Der Vertrag der Rechnungs-API — als Daten, nicht als Prosa.
 *
 * Aus dieser Datei entstehen drei Dinge, damit sie nicht auseinanderlaufen
 * koennen:
 *
 * 1. `fixtures/invoice-api.schema.json` (`npm run fixtures:rechnung`) — das
 *    Backend liest es aus dem vendorierten Paket und vergleicht es in beide
 *    Richtungen mit seiner eigenen Pruefung; der Dart-Zwilling zieht es byteweise.
 * 2. Die Listen unter `rechnung` in `fixtures/surface.json` (Codes, Gruende,
 *    Enums) — ueber denselben Namensraum-Scan wie der Partner-Teil.
 * 3. Die TypeScript-Typen in `typen.ts`.
 *
 * Nach aussen spricht die Schnittstelle Englisch: Feldnamen, Codes, Gruende.
 * Deutsch bleibt, was ein Mensch liest (`message`, der Aufdruck eines Grundes).
 *
 * Beschrieben wird die Anfrage. Was der Server daraus macht — Rechnungsdatum,
 * Nummer, Summen — ist bewusst **nicht** setzbar.
 */
import { RETURN_DISPOSITIONS } from '../models/cancellation.js';
export { RETURN_DISPOSITIONS };
export type { ReturnDisposition } from '../models/cancellation.js';
export declare const INVOICE_CONTRACT_VERSION = 2;
export declare const INVOICE_ENDPOINTS: readonly ["createCustomer", "getCustomer", "updateCustomer", "searchCustomers", "issueInvoice", "cancelInvoice", "createCreditNote", "getInvoice", "listInvoices", "getInvoicePdf", "getInvoiceXml", "getInvoiceSetupStatus", "listBrands", "recordInvoicePayment"];
export type InvoiceEndpoint = (typeof INVOICE_ENDPOINTS)[number];
/**
 * Stabile Fehlercodes. Das Fremdsystem verzweigt am Code, der Text darf sich
 * aendern. `validation` traegt zusaetzlich `errors: [{ field, message }]`.
 */
export declare const INVOICE_ERROR_CODES: readonly ["validation", "idempotency_conflict", "module_inactive", "customer_not_found", "customer_exists", "short_code_taken", "short_code_immutable", "recipient_required", "invoice_requirements_missing", "invoice_not_found", "invoice_ambiguous", "not_cancellable", "partial_credit_exists", "credit_exceeds_invoice", "einvoice_incomplete", "invoice_api_not_enabled", "invoice_setup_incomplete", "language_not_allowed", "brand_not_found", "not_payable", "payment_exceeds_invoice", "tax_scheme_mismatch", "vat_rate_not_in_country", "reverse_charge_reason_required", "reverse_charge_threshold", "mixed_supply_not_allowed", "oss_not_enabled", "einvoice_unavailable", "amount_too_large", "vat_id_invalid", "vat_id_check_pending", "reservation_not_found", "reservation_mismatch", "reservation_not_active", "invoice_number_taken"];
export type InvoiceErrorCode = (typeof INVOICE_ERROR_CODES)[number];
/**
 * Codes, die Anmeldung und Rand auf jedem Rechnungsaufruf erzeugen koennen,
 * soweit sie nicht schon in [INVOICE_ERROR_CODES] stehen: `errorCodes.auth`
 * ohne die sieben des Partner-Zugangs, `errorCodes.edge` (sortiert) und
 * zuletzt `route_missing` (Code des Pakets). [INVOICE_ERROR_CODES] bleibt
 * genau der Katalog des Servers (das Backend vergleicht ihn mit dem Schema);
 * die Helfer in `./invoice` erkennen beide Listen.
 */
export declare const INVOICE_REQUEST_ERROR_CODES: readonly ["account_not_found", "action_confirmation_required", "admin_required", "api_not_approved", "app_check_invalid", "app_check_missing", "cashregister_not_assigned", "cashregister_not_found", "cashregister_token_invalid", "cashregister_token_missing", "dialect_mismatch", "internal_translation_error", "live_not_enabled", "method_not_allowed", "mfa_required", "not_found", "password_change_required", "register_user_no_business", "register_user_not_allowed", "register_user_not_found", "response_translation_failed", "second_factor_required", "session_expired", "session_other_cashregister", "unauthorized", "user_disabled", "user_verification_failed", "route_missing"];
export type InvoiceRequestErrorCode = (typeof INVOICE_REQUEST_ERROR_CODES)[number];
/** Gruende einer Gutschrift. Der Server druckt den deutschen Anzeigetext. */
export declare const CREDIT_NOTE_REASONS: readonly ["cancellation", "price_reduction", "return", "incorrect_invoice", "other"];
export type CreditNoteReason = (typeof CREDIT_NOTE_REASONS)[number];
/**
 * Der Steuerfall einer Rechnung. Er wird vom Server **abgeleitet** (Kundenland,
 * Kundenart, UID, Ware oder Leistung); eine mitgeschickte Angabe muss dazu
 * passen, sonst `tax_scheme_mismatch`. Neue Faelle stehen hinten, damit
 * gespeicherte Reihenfolgen gueltig bleiben. Unter `/v1` hiess `intraCommunitySupply` noch
 * `igLieferung`; unter `/v3` weist der Server den alten Namen mit `validation` ab.
 *
 * - `normal`                oesterreichische Umsatzsteuer
 * - `smallBusiness`         Kleinunternehmer (§ 6 Abs. 1 Z 27 UStG)
 * - `reverseCharge`         Leistung an ein Unternehmen in der EU (Art. 196 MwSt-RL)
 * - `intraCommunitySupply`  Ware an ein Unternehmen in der EU (Art. 6 Abs. 1 UStG)
 * - `exportThirdCountry`    Ware ins Drittland (§ 6 Abs. 1 Z 1 UStG)
 * - `domesticReverseCharge` Uebergang der Steuerschuld im Inland, Grund aus `REVERSE_CHARGE_REASONS`
 * - `oss`                   B2C in der EU ueber den One-Stop-Shop, Satz des Ziellandes
 * - `outsideScope`          Leistung an ein Drittlandsunternehmen — in Oesterreich nicht steuerbar
 */
export declare const TAX_SCHEMES: readonly ["normal", "smallBusiness", "reverseCharge", "intraCommunitySupply", "exportThirdCountry", "domesticReverseCharge", "oss", "outsideScope"];
export type TaxScheme = (typeof TAX_SCHEMES)[number];
/**
 * Gruende fuer den Uebergang der Steuerschuld **im Inland**. Ohne Grund gibt es
 * kein `domesticReverseCharge`: die Bedingungen sind je Fall verschieden, und
 * keine davon laesst sich aus Betrag und Land erraten.
 *
 * `thresholdCents` ist das Entgelt, ab dem der Fall greift – maßgeblich ist das
 * **in der Rechnung ausgewiesene** Entgelt, nicht der Einzelpreis; ein
 * einheitlicher Liefervorgang darf dafuer nicht auf mehrere Rechnungen
 * aufgeteilt werden (UStR Rz 2605d).
 */
export declare const REVERSE_CHARGE_REASONS: Readonly<{
    construction: {
        legalBasis: string;
        thresholdCents: null;
    };
    scrap: {
        legalBasis: string;
        thresholdCents: null;
    };
    mobile_devices: {
        legalBasis: string;
        thresholdCents: number;
    };
    it_devices: {
        legalBasis: string;
        thresholdCents: number;
    };
    metals: {
        legalBasis: string;
        thresholdCents: null;
    };
    emission_certificates: {
        legalBasis: string;
        thresholdCents: null;
    };
    gas_electricity: {
        legalBasis: string;
        thresholdCents: null;
    };
    energy_certificates: {
        legalBasis: string;
        thresholdCents: null;
    };
    investment_gold: {
        legalBasis: string;
        thresholdCents: null;
    };
    security_transfer: {
        legalBasis: string;
        thresholdCents: null;
    };
    foreign_supplier: {
        legalBasis: string;
        thresholdCents: null;
    };
}>;
export type ReverseChargeReason = keyof typeof REVERSE_CHARGE_REASONS;
/** Ware oder Leistung — ohne das laesst sich ig. Lieferung nicht von Reverse Charge trennen. */
export declare const ITEM_KINDS: readonly ["goods", "service"];
export type ItemKind = (typeof ITEM_KINDS)[number];
export declare const PRICE_MODES: readonly ["net", "gross"];
export type PriceMode = (typeof PRICE_MODES)[number];
export declare const VAT_RATES: readonly [0, 10, 13, 20];
export type VatRatePercent = (typeof VAT_RATES)[number];
export declare const CUSTOMER_TYPES: readonly ["private", "company"];
export type CustomerType = (typeof CUSTOMER_TYPES)[number];
export declare const INVOICE_LIST_STATUS: readonly ["final", "paid", "cancelled", "open", "overdue"];
export type InvoiceListStatus = (typeof INVOICE_LIST_STATUS)[number];
/**
 * Belegart: Rechnung oder Gutschrift (unter `/v1` `RE` bzw. `GU`). Das Vorzeichen
 * steht in der Belegart, nie im Betrag.
 */
export declare const DOC_TYPES: readonly ["invoice", "credit_note"];
export type DocType = (typeof DOC_TYPES)[number];
export declare const EINVOICE_FORMATS: readonly ["ubl", "cii"];
export type EInvoiceFormat = (typeof EINVOICE_FORMATS)[number];
/**
 * Was einer EN-16931-konformen E-Rechnung fehlt: `einvoice.missing` jeder
 * Rechnungssicht und `data.missing` bei `einvoice_incomplete` bzw.
 * `invoice_requirements_missing`. Unter `/v1` standen hier deutsche Woerter
 * (`Straße`, `PLZ`, …).
 */
export declare const EINVOICE_MISSING_CODES: readonly ["name", "street", "zip", "city", "country", "vat_id", "order_reference", "order_reference_format"];
export type EInvoiceMissingCode = (typeof EINVOICE_MISSING_CODES)[number];
/** Warum eine Rechnung abgeschrieben wurde (`writeOffReasonCode` in `getInvoice`). */
export declare const WRITE_OFF_REASON_CODES: readonly ["uncollectible", "time_barred", "waived", "disputed", "settled_externally", "other"];
export type WriteOffReasonCode = (typeof WRITE_OFF_REASON_CODES)[number];
/**
 * Sprachen einer Rechnung. Die Sprache wird beim Festschreiben eingefroren;
 * fehlt sie an Kunde oder Rechnung, gilt `de`. Behoerden bekommen immer `de`
 * (`language_not_allowed`). Datum und Betraege bleiben in jeder Sprache
 * oesterreichisch formatiert.
 */
export declare const INVOICE_LANGUAGES: readonly ["de", "en"];
export type InvoiceLanguage = (typeof INVOICE_LANGUAGES)[number];
/**
 * Wie eine Rechnung bezahlt wurde. Der Vermerk ist Buchhaltung, kein Beleg.
 *
 * Ein **Barumsatz** ist nicht nur Bargeld: als Barzahlung gilt auch die Zahlung
 * mit Bankomat- oder Kreditkarte **vor Ort** (§ 131b Abs. 1 Z 3 BAO), nicht
 * aber dieselbe Karte im Internet. Weil `card` und `online` beides sein
 * koennen, sagt das Feld `onSite` es dem Server — und nur dann traegt die
 * Antwort den Hinweis `cash_receipt_required` (bei `cash` immer).
 */
export declare const INVOICE_PAYMENT_METHODS: readonly ["transfer", "card", "online", "cash"];
export type InvoicePaymentMethod = (typeof INVOICE_PAYMENT_METHODS)[number];
/**
 * Hinweise, die eine erfolgreiche Antwort zusaetzlich tragen kann (`data.notice`).
 * Sie sind keine Fehler: der Aufruf hat gewirkt, es gibt nur etwas zu wissen.
 */
export declare const INVOICE_NOTICE_CODES: readonly ["cash_receipt_required", "recapitulative_statement_due", "place_of_supply_check", "reservation_expired"];
export type InvoiceNoticeCode = (typeof INVOICE_NOTICE_CODES)[number];
/**
 * Einheiten einer Position. Die API nimmt nur diese Schluessel an; gedruckt
 * wird das Kuerzel in der Sprache der Rechnung (`INVOICE_TEXTS`,
 * `unit_symbol.<schluessel>`), die E-Rechnung fuehrt den UN/ECE-Code
 * (`INVOICE_UNIT_CODES`). Ohne Angabe gilt `piece`.
 */
export declare const INVOICE_UNITS: readonly ["piece", "pair", "set", "dozen", "second", "minute", "hour", "day", "night", "week", "month", "quarter", "half_year", "year", "milligram", "gram", "kilogram", "tonne", "millimetre", "centimetre", "metre", "running_metre", "kilometre", "square_metre", "hectare", "millilitre", "litre", "cubic_metre", "kilowatt_hour", "megawatt_hour", "gigabyte", "terabyte", "flat_rate", "person", "licence", "user", "device", "session", "trip", "page", "sheet", "package", "box", "carton", "bottle", "can", "roll", "bag", "pallet"];
export type InvoiceUnit = (typeof INVOICE_UNITS)[number];
/**
 * UN/ECE-Code je Einheit (Recommendation 20, Verpackungen aus Recommendation 21
 * mit `X`). Mehrere Einheiten duerfen denselben Code tragen (Meter und
 * Laufmeter; Lizenz, Benutzer, Geraet als Stueck). Die Validatoren der
 * E-Rechnung pruefen jeden Code im Backend (Beispiel `api-einheiten`).
 */
export declare const INVOICE_UNIT_CODES: Readonly<Record<InvoiceUnit, string>>;
/**
 * Was erfuellt sein muss, bevor ueber die API ausgestellt werden darf — in
 * dieser Reihenfolge meldet `getInvoiceSetupStatus`, was fehlt, und dieselben
 * Schluessel stehen in `invoice_setup_incomplete`.
 *
 * - `module_active`  Modul Rechnung aktiv
 * - `api_enabled`    Rechnungs-API fuer das Konto von Kasseneck freigegeben (nur live)
 * - `live_enabled`   Konto live freigeschaltet (nur live)
 * - `business_name`, `address`, `vat_id`  Pflichtangaben des Ausstellers (§ 11 UStG;
 *   `vat_id` entfaellt bei Kleinunternehmern)
 * - `bank_account`   IBAN und Kontoinhaber
 * - `number_format`  Rechnungsnummern-Format bewusst gespeichert
 */
export declare const INVOICE_SETUP_REQUIREMENTS: readonly ["module_active", "api_enabled", "live_enabled", "business_name", "address", "vat_id", "bank_account", "number_format"];
export type InvoiceSetupRequirement = (typeof INVOICE_SETUP_REQUIREMENTS)[number];
/** Formate, die der Server mit `@kreiseck/validator` bzw. einem Muster prueft. */
export type FieldFormat = 'email' | 'phone' | 'vatId' | 'country' | 'date' | 'shortCode';
export type Field = {
    type: 'string';
    required: boolean;
    min?: number;
    max: number;
    format?: FieldFormat;
} | {
    type: 'integer';
    required: boolean;
    min: number;
    max: number;
} | {
    type: 'number';
    required: boolean;
    min: number;
    max: number;
    decimals: number;
    exclusiveMin?: boolean;
} | {
    type: 'boolean';
    required: boolean;
} | {
    type: 'enum';
    required: boolean;
    values: readonly (string | number)[];
} | {
    type: 'object';
    required: boolean;
    fields: Readonly<Record<string, Field>>;
    /**
     * Feldgruppen, von denen GENAU EINE gesetzt sein muss (§ 9.1). Jede Gruppe
     * ist eine Liste von Feldnamen; im JSON Schema wird daraus
     * `oneOf: [{ required: [...] }, ...]`.
     *
     * Gebraucht fuer den Preis einer Position: `unitPriceCents` ODER
     * `unitPriceMicros`, nie beides und nie keines. Als zwei Pflichtfelder
     * liesse sich das nicht ausdruecken, und als zwei optionale waere eine
     * Position ohne Preis gueltig.
     */
    exactlyOne?: readonly (readonly string[])[];
} | {
    type: 'list';
    required: boolean;
    min: number;
    max: number;
    item: Field;
} | {
    type: 'map';
    required: boolean;
    maxKeys: number;
    keyPattern: string;
    valueMax: number;
};
/** Kunde, wie das Fremdsystem ihn schickt. `vatId` ist die UID-Nummer. */
export declare const CUSTOMER_FIELDS: Readonly<Record<string, Field>>;
/**
 * Eine Rechnungs- oder Gutschriftsposition.
 *
 * Der Preis steht in ganzen Cent (`unitPriceCents`) ODER in Mikro-Euro
 * (`unitPriceMicros`, 10⁻⁶ €) — genau eines von beiden (§ 9.1). Der Mikropreis
 * loest denselben Bereich feiner auf: 10¹² Mikro-Euro sind dieselben
 * 10.000.000,00 €, die 10⁸ Cent ausdruecken. Er ist noetig fuer Preise
 * unterhalb eines Cents (Verbrauchsabrechnung, Stueckpreise im Zehntelcent),
 * die bisher gerundet eingereicht werden mussten.
 */
export declare const ITEM_FIELDS: Readonly<Record<string, Field>>;
/**
 * Eine Rechnungsposition beim Ausstellen: die gemeinsamen Positionsfelder plus
 * `reservationId` (seit 1.5.0). Die Reservierung aus der Lager-API
 * (`createReservation`) wird beim Ausstellen geprueft und beim Buchen der
 * Rechnung eingeloest; die Position braucht dazu `articleId`. Unbekannt =
 * `reservation_not_found`, schon eingeloest oder freigegeben =
 * `reservation_not_active`, kein offener Rest dieses Artikels am Lagerstandort
 * der Rechnung (`stockLocationId`, sonst der Standard-Standort) =
 * `reservation_mismatch`; abgelaufen ist kein Fehler, sondern der Hinweis
 * `reservation_expired`. Weniger verkauft als reserviert gibt den Rest frei.
 * Gutschriften kennen das Feld nicht (`validation`).
 */
export declare const INVOICE_ITEM_FIELDS: Readonly<Record<string, Field>>;
/** Genau einer der beiden Preise je Position (§ 9.1). */
export declare const ITEM_PRICE_EXACTLY_ONE: readonly (readonly string[])[];
/**
 * Eine Gutschriftsposition: die gemeinsamen Positionsfelder plus
 * `returnDisposition` (wohin die zurueckgenommene Ware geht), ohne
 * `reservationId`. An einer Rechnungsposition weist der Server
 * `returnDisposition` als unbekannt ab.
 */
export declare const CREDIT_NOTE_ITEM_FIELDS: Readonly<Record<string, Field>>;
/**
 * Eine Zahlung zu einer Rechnung. Ohne `amountCents` gilt der volle
 * Bruttobetrag, ohne `paidAt` der heutige Wiener Tag. `reference` ist die
 * Zahlungskennung des Fremdsystems (z. B. `pi_3Q...`) — sie wird gespeichert,
 * aber **nicht gedruckt**: die Rechnung wird aufbewahrt und vervielfaeltigt,
 * und dem Empfaenger nuetzt sie nichts.
 */
export declare const PAYMENT_FIELDS: Readonly<Record<string, Field>>;
export declare const INVOICE_REQUESTS: Readonly<Record<InvoiceEndpoint, Readonly<Record<string, Field>>>>;
/** Genau eines dieser Felder muss gesetzt sein (je Aufruf, je Gruppe). */
export declare const INVOICE_EXACTLY_ONE: Readonly<Partial<Record<InvoiceEndpoint, readonly (readonly string[])[]>>>;
/** Mindestens eines dieser Felder muss gesetzt sein (je Aufruf, je Gruppe). */
export declare const INVOICE_AT_LEAST_ONE: Readonly<Partial<Record<InvoiceEndpoint, readonly (readonly string[])[]>>>;