@taxora/sdk 1.8.0 → 1.10.0

package/dist/index.d.ts

@@ -110,6 +110,178 @@ declare class AuthEndpoint {
     private parseResponse;
 }
 
+/** One month of the e-invoicing allowance (documents included, used, still free, what is due beyond it). */
+declare class EInvoicingQuotaPeriod {
+    /** Billing period, YYYY-MM. */
+    readonly period: string;
+    readonly used: number;
+    readonly included: number;
+    readonly freeUsed: number;
+    readonly freeRemaining: number;
+    readonly billableUnits: number;
+    /** Net EUR due for documents beyond the allowance. */
+    readonly amount: string;
+    /** Agreed monthly base fee (net EUR) for this month, null when none. */
+    readonly monthlyFee: string | null;
+    /** Net EUR due for the month: base fee + documents beyond the allowance. */
+    readonly total: string;
+    /** open | included | pending_billing | billed */
+    readonly state: string;
+    /** Documents used per country code. */
+    readonly byCountry: Record<string, number>;
+    readonly billedAt: string | null;
+    /** Our invoice number once invoiced. */
+    readonly manualReference: string | null;
+    readonly monthlyFeeReference: string | null;
+    constructor(
+    /** Billing period, YYYY-MM. */
+    period: string, used: number, included: number, freeUsed: number, freeRemaining: number, billableUnits: number, 
+    /** Net EUR due for documents beyond the allowance. */
+    amount: string, 
+    /** Agreed monthly base fee (net EUR) for this month, null when none. */
+    monthlyFee: string | null, 
+    /** Net EUR due for the month: base fee + documents beyond the allowance. */
+    total: string, 
+    /** open | included | pending_billing | billed */
+    state: string, 
+    /** Documents used per country code. */
+    byCountry: Record<string, number>, billedAt: string | null, 
+    /** Our invoice number once invoiced. */
+    manualReference: string | null, monthlyFeeReference: string | null);
+    static fromArray(data: Record<string, unknown>): EInvoicingQuotaPeriod;
+}
+interface EInvoicingQuotaTier {
+    /** Cumulative documents per month up to which the price applies; null = no upper bound. */
+    upTo: number | null;
+    /** Net EUR per document. */
+    unitPrice: string;
+}
+/** The company's e-invoicing allowance: one pool over all e-invoicing countries. */
+declare class EInvoicingQuota {
+    /** How documents beyond the allowance are paid: "subscription" (on the plan's invoice) or "invoice" (invoiced separately). */
+    readonly billing: string;
+    readonly plan: string | null;
+    readonly currency: string;
+    /** Documents included per month. */
+    readonly included: number;
+    readonly tiers: EInvoicingQuotaTier[];
+    readonly countries: string[];
+    /** Agreed monthly base fee (net EUR), null when none. */
+    readonly monthlyFee: string | null;
+    readonly current: EInvoicingQuotaPeriod;
+    /** Earlier months, newest first. */
+    readonly history: EInvoicingQuotaPeriod[];
+    constructor(
+    /** How documents beyond the allowance are paid: "subscription" (on the plan's invoice) or "invoice" (invoiced separately). */
+    billing: string, plan: string | null, currency: string, 
+    /** Documents included per month. */
+    included: number, tiers: EInvoicingQuotaTier[], countries: string[], 
+    /** Agreed monthly base fee (net EUR), null when none. */
+    monthlyFee: string | null, current: EInvoicingQuotaPeriod, 
+    /** Earlier months, newest first. */
+    history: EInvoicingQuotaPeriod[]);
+    static fromArray(data: Record<string, unknown>): EInvoicingQuota;
+}
+
+/** One billable usage event of a summary (only included by billing.getUsageSummaries(period)). */
+interface UsageEvent {
+    id: number;
+    usageSummaryId: number | null;
+    feature: string;
+    country: string | null;
+    regime: string | null;
+    billingPeriod: string;
+    /** What was billed, e.g. a compliance transaction. */
+    resourceType: string | null;
+    resourceId: number | null;
+    stripeUsageRecordId: string | null;
+    stripeReportedAt: string | null;
+    createdAt: string | null;
+}
+/**
+ * Billed usage of one feature (e.g. `ereporting_transaction`) in one billing
+ * period (YYYY-MM) — GET /billing/usage-summaries.
+ */
+declare class UsageSummary {
+    readonly id: number;
+    readonly companyId: number;
+    readonly feature: string;
+    readonly country: string | null;
+    readonly regime: string | null;
+    /** Billing period, YYYY-MM. */
+    readonly billingPeriod: string;
+    readonly eventCount: number;
+    /** Precision-safe decimal string as returned by the API (e.g. "49.00"); null until priced. */
+    readonly billableAmount: string | null;
+    /** e.g. "open"; free-form so new states don't break parsing. */
+    readonly state: string | null;
+    readonly stateLabel: string | null;
+    readonly periodClosedAt: string | null;
+    readonly billingTriggeredAt: string | null;
+    readonly billedAt: string | null;
+    readonly stripeInvoiceId: string | null;
+    readonly stripeSubscriptionItemId: string | null;
+    readonly billingNotes: string | null;
+    /** The period's usage events — only filled by getUsageSummaries(period); empty in the list. */
+    readonly events: UsageEvent[];
+    readonly createdAt: string | null;
+    readonly updatedAt: string | null;
+    constructor(id: number, companyId: number, feature: string, country: string | null, regime: string | null, 
+    /** Billing period, YYYY-MM. */
+    billingPeriod: string, eventCount: number, 
+    /** Precision-safe decimal string as returned by the API (e.g. "49.00"); null until priced. */
+    billableAmount: string | null, 
+    /** e.g. "open"; free-form so new states don't break parsing. */
+    state: string | null, stateLabel: string | null, periodClosedAt: string | null, billingTriggeredAt: string | null, billedAt: string | null, stripeInvoiceId: string | null, stripeSubscriptionItemId: string | null, billingNotes: string | null, 
+    /** The period's usage events — only filled by getUsageSummaries(period); empty in the list. */
+    events: UsageEvent[], createdAt: string | null, updatedAt: string | null);
+    static fromArray(data: Record<string, unknown>): UsageSummary;
+}
+/** A paginated page of usage summaries (newest billing period first). */
+declare class UsageSummaryPage implements Iterable<UsageSummary> {
+    readonly rows: UsageSummary[];
+    readonly currentPage: number;
+    readonly perPage: number;
+    readonly total: number;
+    readonly lastPage: number;
+    constructor(rows: UsageSummary[], currentPage: number, perPage: number, total: number, lastPage: number);
+    static fromResponse(payload: unknown): UsageSummaryPage;
+    [Symbol.iterator](): Iterator<UsageSummary>;
+    get length(): number;
+}
+
+/**
+ * Billing transparency: read-only usage summaries of the company's billable
+ * modules (E-Reporting / E-Invoicing, Smart Enrichment). Requires one of those
+ * modules on the account (403 otherwise). Every call is a GET, so transient
+ * gateway failures are retried (see RetryPolicy).
+ */
+declare class BillingEndpoint {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly tokenStorage;
+    private readonly httpClient;
+    private readonly retryPolicy;
+    constructor(baseUrl: string, apiKey: string, tokenStorage: TokenStorageInterface, httpClient: HttpClientInterface, retryPolicy?: RetryPolicy);
+    /** Paginated usage summaries, newest billing period first. `perPage` is clamped to 1-100 server-side. */
+    listUsageSummaries(page?: number, perPage?: number): Promise<UsageSummaryPage>;
+    /**
+     * The usage summaries of one billing period (YYYY-MM), one per feature,
+     * each with its usage events. A period without usage yields a 404 (HttpException).
+     */
+    getUsageSummaries(period: string): Promise<UsageSummary[]>;
+    /**
+     * The e-invoicing allowance: documents included per month, used, still free and
+     * what is due for the documents beyond it — one pool over all e-invoicing
+     * countries, current month first, then up to `months - 1` earlier months (1-24).
+     * Resolves to null when the company has no e-invoicing.
+     */
+    getEInvoicingQuota(months?: number): Promise<EInvoicingQuota | null>;
+    private buildHeaders;
+    /** GET + envelope unwrap (`{success, data}` → data, which may be an object or an array). */
+    private getJson;
+}
+
 interface CompanyResource {
     id?: number;
     uuid?: string;
@@ -144,6 +316,77 @@ declare class CompanyEndpoint {
     get(): Promise<CompanyResource>;
 }
 
+/**
+ * What to do with an invoice to a buyer, derived from the Peppol directory
+ * (EReportingEndpoint.decideDelivery()).
+ */
+declare const ComplianceDeliveryAction: {
+    /** The buyer can receive e-invoices: create the transaction, Taxora sends it. */
+    readonly EINVOICE: "einvoice";
+    /** The buyer is not on the network: send your regular invoice yourself (a transaction would end as not_required and is not billed). */
+    readonly REGULAR_INVOICE: "regular_invoice";
+    /** No definite directory answer yet: create the transaction anyway, Taxora asks again before sending. */
+    readonly EINVOICE_PENDING: "einvoice_pending";
+};
+type ComplianceDeliveryAction = (typeof ComplianceDeliveryAction)[keyof typeof ComplianceDeliveryAction];
+
+/**
+ * Outcome of a Peppol directory lookup (GET /compliance/peppol-lookup). The
+ * directory resolves asynchronously — `pending` means ask again in a few seconds.
+ */
+declare const PeppolLookupStatus: {
+    readonly REACHABLE: "reachable";
+    readonly NOT_REACHABLE: "not_reachable";
+    readonly PENDING: "pending";
+    readonly UNKNOWN: "unknown";
+};
+type PeppolLookupStatus = (typeof PeppolLookupStatus)[keyof typeof PeppolLookupStatus];
+/** Tolerant coercion: unrecognized values become `unknown` instead of throwing. */
+declare function toPeppolLookupStatus(value: unknown): PeppolLookupStatus;
+declare function describePeppolLookupStatus(status: PeppolLookupStatus): string;
+
+/**
+ * Whether a participant can receive e-invoices over Peppol
+ * (GET /compliance/peppol-lookup). For Norway, `reachable === true` means the
+ * buyer is registered in ELMA and must receive an EHF e-invoice.
+ */
+declare class PeppolLookupResult {
+    readonly status: PeppolLookupStatus;
+    /** null while the lookup is still `pending`. */
+    readonly reachable: boolean | null;
+    readonly country: string;
+    /** Peppol identifier scheme, e.g. "0192" for Norwegian organisation numbers. */
+    readonly scheme: string;
+    /** Participant identifier, e.g. the organisation number. */
+    readonly id: string;
+    /** Peppol document types the participant accepts, e.g. "xml.ubl.invoice.bis3". */
+    readonly documentTypes: string[];
+    readonly transportTypeCode: string | null;
+    readonly checkedAt: string | null;
+    constructor(status: PeppolLookupStatus, 
+    /** null while the lookup is still `pending`. */
+    reachable: boolean | null, country: string, 
+    /** Peppol identifier scheme, e.g. "0192" for Norwegian organisation numbers. */
+    scheme: string, 
+    /** Participant identifier, e.g. the organisation number. */
+    id: string, 
+    /** Peppol document types the participant accepts, e.g. "xml.ubl.invoice.bis3". */
+    documentTypes: string[], transportTypeCode: string | null, checkedAt: string | null);
+    /** True while the directory is still resolving — ask again in a few seconds. */
+    get isPending(): boolean;
+    static fromArray(data: Record<string, unknown>): PeppolLookupResult;
+}
+
+/** The action for one buyer plus the directory answer it is based on (EReportingEndpoint.decideDelivery()). */
+declare class ComplianceDeliveryDecision {
+    readonly action: ComplianceDeliveryAction;
+    readonly lookup: PeppolLookupResult;
+    constructor(action: ComplianceDeliveryAction, lookup: PeppolLookupResult);
+    /** True unless the buyer is not on the network. */
+    get sendsEInvoice(): boolean;
+    static fromLookup(lookup: PeppolLookupResult): ComplianceDeliveryDecision;
+}
+
 declare const ComplianceEnrollmentStatus: {
     readonly PENDING_DATA: "pending_data";
     readonly ACCOUNT_CREATED: "account_created";
@@ -209,6 +452,81 @@ declare class ComplianceEnrollment {
     static fromArray(data: Record<string, unknown>): ComplianceEnrollment;
 }
 
+/** One bookable plan of a country offering. Fees are net EUR amounts. */
+interface ComplianceOfferingPlan {
+    key: string;
+    monthlyFee: number | null;
+    setupFee: number | null;
+    /** Usage tiers as configured server-side (raw objects). */
+    usageTiers: unknown[];
+    volumeLimit: unknown;
+    /** Contact-only plans cannot be booked via createCheckout(). */
+    contactOnly: boolean;
+    /** True when createCheckout() can be started for this plan right now. */
+    checkoutAvailable: boolean;
+    /** Prerequisite of the plan (e.g. `{ country: 'FR', service: 'e_reporting' }`); null when there is none. */
+    requires: {
+        country: string;
+        service: string;
+    } | null;
+    /** Whether the company meets `requires`. */
+    eligible: boolean;
+}
+/** A country offering with the company's current state for it. */
+interface ComplianceOffering {
+    /** Upper-case ISO 3166-1 alpha-2 code. */
+    country: string;
+    /** "e_reporting" or "e_invoicing". */
+    service: string;
+    currency: string;
+    active: boolean;
+    /** The plan was bought via Stripe self-service (vs. granted manually). */
+    viaStripe: boolean;
+    plan: string | null;
+    status: string | null;
+    enrolled: boolean;
+    plans: ComplianceOfferingPlan[];
+}
+/** A country Taxora reaches — bookable self-service or set up on request. */
+interface ComplianceCoverageCountry {
+    country: string;
+    /** "bookable" or "on_request". */
+    availability: string;
+    services: string[];
+    network: string | null;
+    format: string | null;
+    mandate: string | null;
+    /**
+     * "yes", "cross_border_only" (only invoices across the border are reached) or
+     * "coming_soon" (not live yet, can be requested). Older API versions send none: "yes".
+     */
+    support?: string;
+}
+/**
+ * GET /compliance/offerings — bookable compliance plans per country, every
+ * reachable country, and which services the company has unlocked.
+ */
+declare class ComplianceOfferings {
+    readonly offerings: ComplianceOffering[];
+    readonly coverage: ComplianceCoverageCountry[];
+    /** Company-wide: is the service unlocked anywhere. */
+    readonly access: {
+        eReporting: boolean;
+        eInvoicing: boolean;
+    };
+    /** Per country (upper-case code) and service (`e_reporting` / `e_invoicing`). */
+    readonly accessByCountry: Record<string, Record<string, boolean>>;
+    constructor(offerings: ComplianceOffering[], coverage: ComplianceCoverageCountry[], 
+    /** Company-wide: is the service unlocked anywhere. */
+    access: {
+        eReporting: boolean;
+        eInvoicing: boolean;
+    }, 
+    /** Per country (upper-case code) and service (`e_reporting` / `e_invoicing`). */
+    accessByCountry: Record<string, Record<string, boolean>>);
+    static fromArray(data: Record<string, unknown>): ComplianceOfferings;
+}
+
 /**
  * A paginated page of compliance enrollments (GET /compliance/enrollments).
  */
@@ -300,6 +618,8 @@ declare const ComplianceTransactionState: {
     readonly SENDING: "sending";
     readonly SUBMITTED: "submitted";
     readonly ERROR: "error";
+    /** E-invoicing only: the buyer cannot receive e-invoices — nothing was sent or billed; send your regular invoice. */
+    readonly NOT_REQUIRED: "not_required";
     readonly UNKNOWN: "unknown";
 };
 type ComplianceTransactionState = (typeof ComplianceTransactionState)[keyof typeof ComplianceTransactionState];
@@ -338,6 +658,38 @@ interface ComplianceTransactionInvoiceLine {
     unit: number | null;
     taxes: ComplianceTransactionInvoiceLineTax[];
 }
+/** The seller's own invoice PDF attached to an e-invoice (`invoice_pdf`). */
+interface ComplianceTransactionInvoicePdf {
+    filename: string | null;
+    /** Size in bytes. */
+    size: number | null;
+    /** True once the PDF was uploaded to the provider together with the e-invoice. */
+    attached: boolean;
+}
+/**
+ * Non-EUR invoices: the amounts in EUR at the ECB reference rate of the invoice
+ * date (or the last published rate before it) — `eur_equivalent`. A reference
+ * value for bookkeeping; the invoice itself stays in its own currency. Amounts
+ * are decimal strings with two decimals, as returned by the API.
+ */
+interface ComplianceTransactionEurEquivalent {
+    subtotal: string;
+    taxAmount: string;
+    total: string;
+    /** Units of the invoice currency per 1 EUR (ECB reference rate), as a decimal string. */
+    rate: string;
+    /** Date (YYYY-MM-DD) the ECB published the rate used. */
+    rateDate: string | null;
+    /** Where the rate comes from — currently always "ECB". */
+    source: string;
+}
+/**
+ * E-invoicing: the Peppol directory answer about the buyer when it held the
+ * invoice back (`delivery_check`) — e.g. status `not_reachable` (state
+ * `not_required`) or `pending` (retried automatically). Kept as the raw object;
+ * its keys may grow.
+ */
+type ComplianceTransactionDeliveryCheck = Record<string, unknown>;
 /**
  * A recorded compliance transaction (GET/POST /compliance/transactions) — an
  * e-reported transaction (France) or an e-invoice / credit note (Norway).
@@ -396,6 +748,35 @@ declare class ComplianceTransaction {
     readonly providerState: string | null;
     /** The stored invoice lines (empty when the server does not include them). */
     readonly invoiceLines: ComplianceTransactionInvoiceLine[];
+    /**
+     * E-invoicing: URL of the legal e-invoice document once it was sent; null
+     * until then. Download it with `eReporting.getTransactionDocument(id)`.
+     */
+    readonly documentUrl: string | null;
+    /** E-invoicing: Peppol directory answer when the buyer check held the invoice back; null otherwise. */
+    readonly deliveryCheck: ComplianceTransactionDeliveryCheck | null;
+    /** E-invoicing: the attached seller PDF, or null when none is attached. */
+    readonly invoicePdf: ComplianceTransactionInvoicePdf | null;
+    /**
+     * The customer's own reference (order number, ERP id) for searching; never
+     * sent to the buyer or the tax authority. Null when not set.
+     */
+    readonly internalReference: string | null;
+    /**
+     * URL of the invoice as a readable PDF (the attached seller PDF or the
+     * provider's rendering of the e-invoice); null when no PDF is available.
+     * Download it with `eReporting.getTransactionPdf(id)`.
+     */
+    readonly pdfUrl: string | null;
+    /** E-invoicing: the buyer refused the invoice (provider state `refused`) — correct it with a credit note. */
+    readonly buyerRejected: boolean;
+    /** E-invoicing: the buyer's reason for the rejection, when given. */
+    readonly rejectionReason: string | null;
+    /**
+     * Non-EUR invoices: the amounts in EUR at the ECB reference rate of the
+     * invoice date. Null for EUR invoices or when no rate is known.
+     */
+    readonly eurEquivalent: ComplianceTransactionEurEquivalent | null;
     constructor(id: number, companyId: number, complianceEnrollmentId: number, country: string, regime: string, transactionType: ComplianceTransactionType, transactionTypeLabel: string, state: ComplianceTransactionState, stateLabel: string, invoiceNumber: string, 
     /** Invoice date (YYYY-MM-DD). */
     invoiceDate: string | null, dueDate: string | null, currency: string, subtotal: string, taxAmount: string, total: string, counterpartyName: string | null, counterpartyCountry: string | null, counterpartyVatNumber: string | null, isPaid: boolean, paidAt: string | null, providerInvoiceId: string | null, submissionError: string | null, reportedAt: string | null, 
@@ -416,7 +797,36 @@ declare class ComplianceTransaction {
      */
     providerState?: string | null, 
     /** The stored invoice lines (empty when the server does not include them). */
-    invoiceLines?: ComplianceTransactionInvoiceLine[]);
+    invoiceLines?: ComplianceTransactionInvoiceLine[], 
+    /**
+     * E-invoicing: URL of the legal e-invoice document once it was sent; null
+     * until then. Download it with `eReporting.getTransactionDocument(id)`.
+     */
+    documentUrl?: string | null, 
+    /** E-invoicing: Peppol directory answer when the buyer check held the invoice back; null otherwise. */
+    deliveryCheck?: ComplianceTransactionDeliveryCheck | null, 
+    /** E-invoicing: the attached seller PDF, or null when none is attached. */
+    invoicePdf?: ComplianceTransactionInvoicePdf | null, 
+    /**
+     * The customer's own reference (order number, ERP id) for searching; never
+     * sent to the buyer or the tax authority. Null when not set.
+     */
+    internalReference?: string | null, 
+    /**
+     * URL of the invoice as a readable PDF (the attached seller PDF or the
+     * provider's rendering of the e-invoice); null when no PDF is available.
+     * Download it with `eReporting.getTransactionPdf(id)`.
+     */
+    pdfUrl?: string | null, 
+    /** E-invoicing: the buyer refused the invoice (provider state `refused`) — correct it with a credit note. */
+    buyerRejected?: boolean, 
+    /** E-invoicing: the buyer's reason for the rejection, when given. */
+    rejectionReason?: string | null, 
+    /**
+     * Non-EUR invoices: the amounts in EUR at the ECB reference rate of the
+     * invoice date. Null for EUR invoices or when no rate is known.
+     */
+    eurEquivalent?: ComplianceTransactionEurEquivalent | null);
     get isCreditNote(): boolean;
     static fromArray(data: Record<string, unknown>): ComplianceTransaction;
 }
@@ -456,53 +866,6 @@ declare class ImportResult {
     static fromArray(data: Record<string, unknown>): ImportResult;
 }
 
-/**
- * Outcome of a Peppol directory lookup (GET /compliance/peppol-lookup). The
- * directory resolves asynchronously — `pending` means ask again in a few seconds.
- */
-declare const PeppolLookupStatus: {
-    readonly REACHABLE: "reachable";
-    readonly NOT_REACHABLE: "not_reachable";
-    readonly PENDING: "pending";
-    readonly UNKNOWN: "unknown";
-};
-type PeppolLookupStatus = (typeof PeppolLookupStatus)[keyof typeof PeppolLookupStatus];
-/** Tolerant coercion: unrecognized values become `unknown` instead of throwing. */
-declare function toPeppolLookupStatus(value: unknown): PeppolLookupStatus;
-declare function describePeppolLookupStatus(status: PeppolLookupStatus): string;
-
-/**
- * Whether a participant can receive e-invoices over Peppol
- * (GET /compliance/peppol-lookup). For Norway, `reachable === true` means the
- * buyer is registered in ELMA and must receive an EHF e-invoice.
- */
-declare class PeppolLookupResult {
-    readonly status: PeppolLookupStatus;
-    /** null while the lookup is still `pending`. */
-    readonly reachable: boolean | null;
-    readonly country: string;
-    /** Peppol identifier scheme, e.g. "0192" for Norwegian organisation numbers. */
-    readonly scheme: string;
-    /** Participant identifier, e.g. the organisation number. */
-    readonly id: string;
-    /** Peppol document types the participant accepts, e.g. "xml.ubl.invoice.bis3". */
-    readonly documentTypes: string[];
-    readonly transportTypeCode: string | null;
-    readonly checkedAt: string | null;
-    constructor(status: PeppolLookupStatus, 
-    /** null while the lookup is still `pending`. */
-    reachable: boolean | null, country: string, 
-    /** Peppol identifier scheme, e.g. "0192" for Norwegian organisation numbers. */
-    scheme: string, 
-    /** Participant identifier, e.g. the organisation number. */
-    id: string, 
-    /** Peppol document types the participant accepts, e.g. "xml.ubl.invoice.bis3". */
-    documentTypes: string[], transportTypeCode: string | null, checkedAt: string | null);
-    /** True while the directory is still resolving — ask again in a few seconds. */
-    get isPending(): boolean;
-    static fromArray(data: Record<string, unknown>): PeppolLookupResult;
-}
-
 /**
  * A company from a national company register (GET /compliance/registry-lookup) —
  * for Norway the Brønnøysund Enhetsregisteret. Maps onto the Norway enrollment
@@ -653,6 +1016,31 @@ declare class VatRates {
     static fromArray(data: Record<string, unknown>): VatRates;
 }
 
+declare const Language: {
+    readonly ENGLISH: "en";
+    readonly GERMAN: "de";
+};
+type Language = (typeof Language)[keyof typeof Language];
+
+/**
+ * Tax category of an invoice line (UNCL5305 / DGFiP codes). Which categories and rates a country
+ * accepts is in eReporting.getVatRates(); Norway uses S (25 / 15 / 12 %), Z, E (with a VATEX code)
+ * and AE (reverse charge).
+ */
+declare const ComplianceTaxCategory: {
+    readonly STANDARD: "S";
+    readonly REDUCED: "AA";
+    readonly SUPER_REDUCED: "AAA";
+    readonly INTRA_COMMUNITY: "K";
+    readonly EXPORT: "G";
+    readonly REVERSE_CHARGE: "AE";
+    readonly EXEMPT: "E";
+    readonly ZERO: "Z";
+};
+type ComplianceTaxCategory = (typeof ComplianceTaxCategory)[keyof typeof ComplianceTaxCategory];
+/** Strict mapping for input: any case is accepted, an unknown code returns null. */
+declare function parseComplianceTaxCategory(value: unknown): ComplianceTaxCategory | null;
+
 /** Time-series bucket size accepted by the revenue statistics endpoint. */
 type EReportingInterval = 'day' | 'week' | 'month';
 /** Enterprise size categories accepted by the DGFiP enrollment. */
@@ -674,6 +1062,70 @@ interface RevenueStatisticsFilters {
     interval?: EReportingInterval;
     transactionType?: ComplianceTransactionRequestType;
     state?: ComplianceTransactionRequestState;
+    /** Only this enrollment's transactions — one country's figures (e.g. France or Norway). */
+    complianceEnrollmentId?: number;
+}
+/** Filters for exportRevenueTaxRatesCsv() — the revenue statistics filters without `interval`. */
+type RevenueTaxRatesCsvFilters = Omit<RevenueStatisticsFilters, 'interval'>;
+/** A transaction download: the legal e-invoice document (getTransactionDocument()) or the invoice PDF (getTransactionPdf()). */
+interface ComplianceTransactionDocument {
+    /** Raw bytes as delivered by the network (e.g. the EHF/UBL XML). */
+    content: Uint8Array;
+    /** Content-Type header of the download, e.g. "application/xml". */
+    contentType: string;
+    /** Filename from Content-Disposition; null when the header is missing. */
+    filename: string | null;
+}
+/** createCheckout() result: open `url` in the browser to pay via Stripe Checkout. */
+interface ComplianceCheckoutSession {
+    id: string;
+    url: string;
+}
+/** Digest email schedule: daily at 08:00 for the day before, weekly on Mondays for the last 7 days. */
+type ComplianceNotificationDigest = 'off' | 'daily' | 'weekly';
+/** getNotificationSettings() / updateNotificationSettings() result: the company's opt-in compliance emails. */
+interface ComplianceNotificationSettings {
+    /** Up to 5 email addresses (lower-cased by the server). */
+    recipients: string[];
+    /** Language of the emails. */
+    language: Language;
+    /** Email (at most hourly) listing new invoices held back because the buyer is not on Peppol. */
+    notOnPeppol: boolean;
+    digest: ComplianceNotificationDigest;
+    /** ISO 8601 timestamp of the last digest sent; null when none was sent yet. */
+    digestSentAt: string | null;
+}
+/** updateNotificationSettings() input: only the provided fields change (at least one is required). */
+interface UpdateComplianceNotificationSettingsInput {
+    /** Replaces the whole list (max 5 addresses); `[]` clears it. */
+    recipients?: string[];
+    language?: Language;
+    notOnPeppol?: boolean;
+    digest?: ComplianceNotificationDigest;
+}
+/** confirmCheckout() result: the plan state after the checkout. */
+interface ComplianceCheckoutConfirmation {
+    active: boolean;
+    country: string | null;
+    service: string | null;
+    plan: string | null;
+    status: string | null;
+}
+/**
+ * The seller's own invoice PDF: raw bytes (Uint8Array — a Node Buffer works —
+ * or ArrayBuffer), base64-encoded by the SDK; or a string that is already
+ * base64 (a `data:application/pdf;base64,` prefix is accepted).
+ */
+type ComplianceInvoicePdfInput = Uint8Array | ArrayBuffer | string;
+/**
+ * E-invoicing only: attach your own invoice PDF as the e-invoice's visual
+ * representation (max 10 MB). The structured e-invoice stays the legal
+ * document. Rejected with 422 when the country is not booked as e-invoicing.
+ */
+interface ComplianceInvoicePdfFields {
+    invoicePdf?: ComplianceInvoicePdfInput;
+    /** Filename for the PDF (max 120 chars); defaults server-side to the invoice number. */
+    invoicePdfFilename?: string;
 }
 /**
  * France (DGFiP e-reporting) enrollment — the original createEnrollment() input.
@@ -751,8 +1203,8 @@ interface ComplianceInvoiceTaxInput {
     name: string;
     /** VAT percentage, e.g. 20 or 5.5. */
     percent: number;
-    /** DGFiP tax category code (S/AA/AAA/K/G/AE/E/Z) — see getVatRates(). */
-    category: string;
+    /** Tax category code (S/AA/AAA/K/G/AE/E/Z, any case) — see getVatRates() for what a country accepts. */
+    category: ComplianceTaxCategory | Lowercase<ComplianceTaxCategory>;
     /** VATEX exemption code; required when `category` is "E". */
     comment?: string;
 }
@@ -792,7 +1244,7 @@ interface ComplianceTransactionBuyerInput {
     /** Free-text note printed on the invoice (max 1000 chars). */
     extraInfo?: string;
 }
-interface CreateComplianceTransactionInput extends ComplianceTransactionBuyerInput {
+interface CreateComplianceTransactionInput extends ComplianceTransactionBuyerInput, ComplianceInvoicePdfFields {
     complianceEnrollmentId: number;
     transactionType: ComplianceTransactionRequestType;
     invoiceNumber: string;
@@ -816,10 +1268,15 @@ interface CreateComplianceTransactionInput extends ComplianceTransactionBuyerInp
     remittanceInformation?: string;
     paymentMethodText?: string;
     paymentTerms?: string;
+    /**
+     * Your own reference (order number, ERP id), max 100 chars. Stored for your search
+     * only — never sent to the buyer or the tax authority.
+     */
+    internalReference?: string;
     /** When false, the transaction is only recorded — submission is deferred. Defaults to true server-side. */
     submitNow?: boolean;
 }
-interface UpdateComplianceTransactionInput extends ComplianceTransactionBuyerInput {
+interface UpdateComplianceTransactionInput extends ComplianceTransactionBuyerInput, ComplianceInvoicePdfFields {
     transactionType?: ComplianceTransactionRequestType;
     invoiceNumber?: string;
     invoiceDate?: Date | string;
@@ -840,6 +1297,30 @@ interface UpdateComplianceTransactionInput extends ComplianceTransactionBuyerInp
     remittanceInformation?: string;
     paymentMethodText?: string;
     paymentTerms?: string;
+    /**
+     * Your own reference (order number, ERP id), max 100 chars. Stored for your search
+     * only — never sent to the buyer or the tax authority. An empty string clears it.
+     */
+    internalReference?: string;
+}
+/**
+ * createCreditNote() input. Without invoiceLines and amounts the whole invoice is
+ * credited; for a partial credit pass invoiceLines, subtotal, taxAmount and total together.
+ */
+interface CreateCreditNoteInput extends ComplianceInvoicePdfFields {
+    /** The credit note's own number (max 50 chars). */
+    creditNoteNumber: string;
+    /** Defaults to today. */
+    invoiceDate?: Date | string;
+    /** Partial credit: the credited lines. */
+    invoiceLines?: ComplianceInvoiceLineInput[];
+    subtotal?: number;
+    taxAmount?: number;
+    total?: number;
+    extraInfo?: string;
+    /** Your own reference (order number, RMA id), max 100 chars. */
+    internalReference?: string;
+    submitNow?: boolean;
 }
 interface ComplianceTransactionFilters {
     /** Inclusive lower bound on the invoice date (Date or strict YYYY-MM-DD). */
@@ -852,10 +1333,18 @@ interface ComplianceTransactionFilters {
     complianceEnrollmentId?: number;
     /** Only transactions of this country (2-char ISO 3166-1 alpha-2). */
     country?: string;
+    /** Contains-match over invoice number, internal reference and buyer name (max 100 chars). */
+    search?: string;
+    /** Exact match on the internal reference (max 100 chars). */
+    internalReference?: string;
+    /** Provider delivery state (lowercase letters/underscore, max 30), e.g. `refused` = rejected by the buyer. */
+    providerState?: string;
     page?: number;
     /** Page size (1-100, default 25 server-side). */
     perPage?: number;
 }
+/** Filters for exportTransactionsCsv() — the transaction list filters without pagination. */
+type ComplianceTransactionExportFilters = Omit<ComplianceTransactionFilters, 'page' | 'perPage'>;
 interface EReportingAccessRequestInput {
     name?: string;
     email?: string;
@@ -883,6 +1372,8 @@ interface EReportingAccessRequestInput {
  *
  * Each country/service is unlocked (and billed) separately; enrolling for a
  * service the company does not have yields a 403 with code `service_not_active`.
+ * Write requests (create/update/delete/submit/import) by a user whose only role
+ * is read-only yield a 403 (HttpException) with body code `read_only_role`.
  * All routes except requestEReportingAccess() require compliance access on the
  * account.
  */
@@ -952,6 +1443,17 @@ declare class EReportingEndpoint {
      * (HttpException) on provider failure.
      */
     peppolLookup(country: string, id: string, scheme?: string): Promise<PeppolLookupResult>;
+    /**
+     * What to do with an invoice to this buyer: peppolLookup() turned into an action,
+     * e.g. in a shop checkout when a business buyer enters its number.
+     *
+     * - `einvoice`: create the transaction, Taxora sends the e-invoice;
+     * - `regular_invoice`: the buyer is not on the network — send your regular invoice
+     *   yourself (a transaction would end as not_required and is not billed);
+     * - `einvoice_pending`: no definite answer yet — create the transaction anyway,
+     *   Taxora asks the directory again before sending.
+     */
+    decideDelivery(country: string, id: string, scheme?: string): Promise<ComplianceDeliveryDecision>;
     /**
      * Record and (by default) submit a Flux 10 transaction. Pass `submitNow: false`
      * to only record it — submission can be triggered later via submitTransaction().
@@ -967,8 +1469,36 @@ declare class EReportingEndpoint {
      * On provider failure the API responds 502 (mapped to an HttpException).
      */
     createTransaction(input: CreateComplianceTransactionInput): Promise<ComplianceTransaction>;
-    /** Paginated list of the company's transactions (newest invoice date first), filterable by date / state / type / enrollment / country. */
+    /**
+     * Issue a credit note for an invoice you sent through Taxora. Everything that must
+     * match the corrected invoice is taken from `original`: enrollment, transaction type,
+     * currency, buyer (name, register id, address, e-mail, VAT number, buyer reference) —
+     * and the reference to the corrected invoice (number and date) is set for you.
+     *
+     * Without invoiceLines and amounts it credits the whole invoice: lines and amounts are
+     * taken over as they are (the document type, not the sign, makes it a credit note).
+     * For a partial credit pass invoiceLines, subtotal, taxAmount and total together.
+     *
+     * Not possible for an invoice that was never sent to the buyer (state not_required)
+     * or for a credit note. A buyer rejected the invoice? Correct it with a credit note and
+     * send a new invoice (`original.buyerRejected`).
+     */
+    createCreditNote(original: ComplianceTransaction, input: CreateCreditNoteInput): Promise<ComplianceTransaction>;
+    /** Paginated list of the company's transactions (newest invoice date first), filterable by date / state / type / enrollment / country / search / internal reference / provider state. */
     listTransactions(filters?: ComplianceTransactionFilters): Promise<ComplianceTransactionPage>;
+    /**
+     * All transactions matching the filters as raw CSV for bookkeeping
+     * (semicolon-separated) — the same filters as listTransactions() without
+     * pagination. Columns: invoice_number, internal_reference, invoice_date,
+     * due_date, country, transaction_type, document_type, state, delivery_state,
+     * buyer_rejected, rejection_reason, counterparty_name, counterparty_country,
+     * counterparty_vat_number, currency, subtotal, tax_amount, total, eur_rate,
+     * eur_rate_date, eur_subtotal, eur_tax_amount, eur_total, provider_invoice_id,
+     * created_at. The eur_* columns hold the ECB reference conversion for non-EUR
+     * invoices (empty for EUR). Max 50,000 rows server-side. The body is returned
+     * verbatim, a UTF-8 BOM included when the API sends one.
+     */
+    exportTransactionsCsv(filters?: ComplianceTransactionExportFilters): Promise<string>;
     /** Get a single transaction by id (includes its tax report when one exists). */
     getTransaction(id: number): Promise<ComplianceTransaction>;
     /** Update a still-pending transaction. Only the provided fields are sent; already-submitted transactions are rejected with 422. */
@@ -986,6 +1516,25 @@ declare class EReportingEndpoint {
      * already-submitted transactions are rejected with 422.
      */
     submitTransaction(id: number): Promise<ComplianceTransaction>;
+    /**
+     * Download the legal e-invoice document of a sent transaction (e-invoicing,
+     * e.g. the EHF/UBL XML for Norway). Available once `documentUrl` on the
+     * transaction is set.
+     *
+     * Errors: 404 (HttpException) for an unknown transaction; 409 (HttpException)
+     * when no document exists (yet) — e.g. e-reporting, not sent, or the network
+     * has not produced it yet (try again in a few minutes); 502 on provider failure.
+     */
+    getTransactionDocument(id: number): Promise<ComplianceTransactionDocument>;
+    /**
+     * Download the invoice as a readable PDF — the seller's attached PDF, or the
+     * provider's rendering of the e-invoice. Available once `pdfUrl` on the
+     * transaction is set.
+     *
+     * Errors: 404 (HttpException) for an unknown transaction; 409 (HttpException)
+     * when no PDF exists (yet); 502 on provider failure.
+     */
+    getTransactionPdf(id: number): Promise<ComplianceTransactionDocument>;
     /**
      * Bulk-import transactions from a semicolon-separated CSV (one row per invoice
      * line; rows sharing an invoice_number are grouped into one transaction).
@@ -1003,14 +1552,25 @@ declare class EReportingEndpoint {
      * months and a monthly interval.
      */
     getRevenueStatistics(filters?: RevenueStatisticsFilters): Promise<RevenueStatistics>;
+    /**
+     * Net and VAT per month, currency and tax rate as raw CSV (semicolon-separated,
+     * computed from the invoice lines) — for reconciling the reported figures with
+     * your VAT return. Same filters as getRevenueStatistics() (without
+     * `interval`); defaults to the last 12 months. The body is returned verbatim,
+     * a UTF-8 BOM included when the API sends one.
+     */
+    exportRevenueTaxRatesCsv(filters?: RevenueTaxRatesCsvFilters): Promise<string>;
     /**
      * The canonical VAT rates & DGFiP tax categories for a reporting country
      * (the seller's reporting-country rates, not the counterparty's). Falls back
      * to the configured default country (FR) when none/unknown is given.
      */
     getVatRates(country?: string): Promise<VatRates>;
-    /** Paginated list of the company's tax reports (newest first), optionally filtered by state. */
-    listTaxReports(page?: number, perPage?: number, state?: ComplianceTaxReportRequestState): Promise<ComplianceTaxReportPage>;
+    /**
+     * Paginated list of the company's tax reports (newest first), optionally
+     * filtered by state and by country (2-letter ISO code, case-insensitive).
+     */
+    listTaxReports(page?: number, perPage?: number, state?: ComplianceTaxReportRequestState, country?: string): Promise<ComplianceTaxReportPage>;
     /** Get a single tax report by id. */
     getTaxReport(id: number): Promise<ComplianceTaxReport>;
     /**
@@ -1023,6 +1583,48 @@ declare class EReportingEndpoint {
      * returned as HTTP 400 (surfaced as HttpException), not 422.
      */
     requestEReportingAccess(input?: EReportingAccessRequestInput): Promise<void>;
+    /**
+     * Bookable compliance plans per country (net EUR prices), every country
+     * Taxora reaches, and which services the company has unlocked. Works for
+     * companies without compliance access.
+     */
+    getOfferings(): Promise<ComplianceOfferings>;
+    /**
+     * Start a Stripe Checkout for a plan (see getOfferings() — `checkoutAvailable`).
+     * Open the returned `url` in the browser. After payment Stripe redirects to
+     * the Taxora portal, which activates the plan; call confirmCheckout() with the
+     * session id to activate it from your side (idempotent).
+     *
+     * Errors: 422 (ValidationException) for an unknown or contact-only plan or a
+     * plan that is already active; 502 (HttpException) on a Stripe error.
+     */
+    createCheckout(country: string, plan: string): Promise<ComplianceCheckoutSession>;
+    /** Confirm a finished Stripe Checkout and activate its plan. Idempotent. */
+    confirmCheckout(sessionId: string): Promise<ComplianceCheckoutConfirmation>;
+    /**
+     * URL of the Stripe billing portal for the company's compliance plans
+     * (invoices, payment method, cancellation). The portal returns to the Taxora
+     * portal. 404 (HttpException) when no plan was bought via Stripe.
+     */
+    createBillingPortalSession(): Promise<string>;
+    /**
+     * The company's opt-in e-reporting / e-invoicing emails: recipients, language,
+     * the "buyer not on Peppol" email and the digest. Readable by every member.
+     */
+    getNotificationSettings(): Promise<ComplianceNotificationSettings>;
+    /**
+     * Change the company's e-reporting / e-invoicing emails; only the provided
+     * fields change. `notOnPeppol` only reports invoices held back after it was
+     * switched on.
+     *
+     * Errors: 422 (ValidationException) when an email is switched on without any
+     * recipient; 403 (HttpException, body code `admin_only` or `read_only_role`)
+     * for users who are not company admins.
+     */
+    updateNotificationSettings(input: UpdateComplianceNotificationSettingsInput): Promise<ComplianceNotificationSettings>;
+    private toNotificationSettings;
+    /** Validated transaction-list filters as query params (shared by listTransactions and exportTransactionsCsv). */
+    private buildTransactionFilterParams;
     private validateEnrollmentInput;
     private isNorwayEnrollmentInput;
     /** Validates the Norway input and builds its wire body (org number normalized to 9 digits). */
@@ -1036,6 +1638,16 @@ declare class EReportingEndpoint {
     private validateTransactionType;
     private validateInvoiceNumber;
     private validateInvoiceLines;
+    private validateInvoicePdfFilename;
+    private validateInternalReference;
+    /**
+     * Relations that cannot be right: a due date before the invoice date, a credit note without (or an
+     * invoice with) a corrected invoice, a credit note that reuses the number it corrects, a corrected
+     * invoice dated after the credit note.
+     */
+    private validateDocument;
+    /** A category read back from a stored invoice; one that is not a known code cannot be re-sent. */
+    private storedTaxCategory;
     private validateOptionalCodes;
     /**
      * Format checks for the buyer/document fields. Country rules (e.g. the Norway
@@ -1046,8 +1658,14 @@ declare class EReportingEndpoint {
     private buildInvoiceLines;
     /** Applies the optional scalar fields shared by create and update. */
     private applyOptionalTransactionFields;
+    /** Bytes → base64 (validated as a PDF of at most 10 MB); strings are taken as already base64. */
+    private encodeInvoicePdf;
     private buildHeaders;
     private sendRequest;
+    /** GET for a non-JSON download (CSV / document): no JSON Content-Type, retried like other GETs. */
+    private sendDownloadRequest;
+    /** `attachment; filename="x.xml"` (or RFC 5987 `filename*=UTF-8''x.xml`) → "x.xml". */
+    private filenameFromDisposition;
     /** Multipart upload: Content-Type is left to fetch so the boundary is set correctly. */
     private sendMultipartRequest;
     /** Accepts any 2xx response (e.g. 201 on create, 200 on idempotent replay). */
@@ -1896,12 +2514,6 @@ interface LocalTaxNumberReportOptions {
  */
 declare function parseLocalTaxNumbersCsv(csv: string): LocalTaxNumberRow[];
 
-declare const Language: {
-    readonly ENGLISH: "en";
-    readonly GERMAN: "de";
-};
-type Language = (typeof Language)[keyof typeof Language];
-
 declare class VatEndpoint {
     private readonly baseUrl;
     private readonly apiKey;
@@ -1961,6 +2573,7 @@ declare class TaxoraClient {
     readonly company: CompanyEndpoint;
     readonly smartEnrichment: SmartEnrichmentEndpoint;
     readonly eReporting: EReportingEndpoint;
+    readonly billing: BillingEndpoint;
     readonly baseUrl: string;
     constructor(options: TaxoraClientOptions);
 }
@@ -1974,6 +2587,51 @@ declare const ApiVersion: {
 };
 type ApiVersion = (typeof ApiVersion)[keyof typeof ApiVersion];
 
+interface InvoiceTotals {
+    /** Sum of the line net amounts, 2 decimals. */
+    subtotal: number;
+    /** Sum of the line VAT amounts, 2 decimals. */
+    taxAmount: number;
+    /** subtotal + taxAmount, 2 decimals. */
+    total: number;
+    /** Expected total minus computed total (0 when no expected total was given). */
+    roundingDifference: number;
+}
+interface InvoiceTotalsOptions {
+    /**
+     * The total your own system shows the buyer. The totals always follow the lines (the e-invoice is built
+     * from them); this only checks that your total is within rounding distance and reports the difference.
+     */
+    expectedTotal?: number;
+    /** Largest accepted difference to the expected total (default 0.05). */
+    tolerance?: number;
+}
+/**
+ * Subtotal, VAT and total of invoice lines, computed the way the e-invoice is built: every line is
+ * quantity × price rounded to cents, VAT per line at the rates of its taxes. Use it so the header
+ * amounts of createTransaction() always match the lines (the API refuses an e-invoice whose amounts
+ * disagree with its lines).
+ */
+declare function calculateInvoiceTotals(lines: ComplianceInvoiceLineInput[], options?: InvoiceTotalsOptions): InvoiceTotals;
+
+/**
+ * Taxes for invoice lines without remembering category codes. The rate itself is the seller's to know;
+ * the API checks it against the country's catalogue (see eReporting.getVatRates()). The name defaults to "VAT".
+ */
+declare const ComplianceTax: {
+    /**
+     * A taxed rate above 0 %, category S (Norway: 25 / 15 / 12 % are all S). Where a country files reduced rates
+     * under their own category (France: AA / AAA), pass it as `category`.
+     */
+    readonly rate: (percent: number, name?: string, category?: ComplianceInvoiceTaxInput["category"]) => ComplianceInvoiceTaxInput;
+    /** 0 % but taxable (category Z). */
+    readonly zeroRated: (name?: string) => ComplianceInvoiceTaxInput;
+    /** Exempt from VAT (category E); the VATEX exemption code is mandatory. */
+    readonly exempt: (exemptionCode: string, name?: string) => ComplianceInvoiceTaxInput;
+    /** Reverse charge (category AE); the mandatory legal text is added by Taxora. */
+    readonly reverseCharge: (name?: string) => ComplianceInvoiceTaxInput;
+};
+
 /**
  * Norwegian organisation number (organisasjonsnummer): 9 digits, the last one a
  * modulus-11 check digit (weights 3,2,7,6,5,4,3,2). It is also the Peppol
@@ -2041,13 +2699,40 @@ interface ComplianceLedgerWebhookObject {
     ledger_type: string | null;
     ledger_date: string | null;
 }
+/**
+ * `compliance.transaction.state_changed` payload. Sent for every real change of a
+ * transaction — Taxora's own state (submitted, error, not_required) and the
+ * provider's delivery state (accepted, refused, paid, …); never twice for the
+ * same state and never for the transient `sending`.
+ *
+ * The optional fields were added later and are missing on older deliveries.
+ */
 interface ComplianceTransactionWebhookObject {
     id: number;
+    /** A ComplianceTransactionState value, e.g. `submitted`, `error`, `not_required`. */
     state: string;
+    /** Provider-side delivery state, e.g. `sent`, `accepted`, `refused`, `paid`. */
     provider_state: string | null;
+    /** Lowercase ISO 3166-1 alpha-2 code, e.g. `no`. */
     country: string | null;
     invoice_number: string | null;
-}
+    /** Your own reference of the transaction. */
+    internal_reference?: string | null;
+    /** Taxora state before this change. */
+    previous_state?: string | null;
+    /** Provider state before this change. */
+    previous_provider_state?: string | null;
+    /** The buyer refused the e-invoice — issue a credit note. */
+    buyer_rejected?: boolean;
+    /** The buyer's reason for the rejection, when given. */
+    rejection_reason?: string | null;
+    /** Why sending failed (state `error`). */
+    submission_error?: string | null;
+    /** Peppol directory result, e.g. `not_reachable` when the state is `not_required`. */
+    delivery_check?: string | null;
+}
+/** True when the buyer refused the e-invoice (false for older deliveries without the field). */
+declare function isTransactionBuyerRejected(object: ComplianceTransactionWebhookObject): boolean;
 /** Raw Smart Enrichment rows — wrap them with `SmartEnrichmentResource.fromArray()` for a typed DTO. */
 interface EnrichmentCompletedWebhookObject {
     jobId: string;
@@ -2210,4 +2895,4 @@ declare class AuthRetryHttpClient implements HttpClientInterface {
     private injectAuthHeader;
 }
 
-export { ApiVersion, AuthEndpoint, AuthRetryHttpClient, AuthenticationException, CompanyAddress, CompanyEndpoint, type CompanyResource, ComplianceDocumentType, ComplianceEnrollment, ComplianceEnrollmentPage, ComplianceEnrollmentStatus, type ComplianceEnterpriseSize, type ComplianceInvoiceLineInput, type ComplianceInvoiceTaxInput, type ComplianceLedgerStateChangedEvent, type ComplianceLedgerWebhookObject, type ComplianceRequestService, ComplianceService, ComplianceTaxReport, ComplianceTaxReportPage, type ComplianceTaxReportRequestState, ComplianceTaxReportState, ComplianceTransaction, type ComplianceTransactionBuyerInput, type ComplianceTransactionFilters, type ComplianceTransactionInvoiceLine, type ComplianceTransactionInvoiceLineTax, ComplianceTransactionPage, type ComplianceTransactionRequestState, type ComplianceTransactionRequestType, ComplianceTransactionState, type ComplianceTransactionStateChangedEvent, ComplianceTransactionType, type ComplianceTransactionWebhookObject, type ComplianceTypeOperation, type CreateComplianceEnrollmentInput, type CreateComplianceTransactionInput, type CreateNorwayEnrollmentInput, DEFAULT_WEBHOOK_TOLERANCE_SECONDS, type EReportingAccessRequestInput, EReportingEndpoint, type EReportingInterval, type EnrichmentCompletedEvent, type EnrichmentCompletedWebhookObject, type EnrichmentUpdatedEvent, type EnrichmentUpdatedWebhookObject, Environment, Environment as EnvironmentType, FetchHttpClient, type HttpClientInterface, HttpException, ImportResult, InMemoryTokenStorage, Language, type LocalTaxNumberReportOptions, LocalTaxNumberRow, type LocalTaxNumberSummary, LoginIdentifier, type NorwayEnrollmentInput, NorwegianOrgNumber, type ParsedWebhookSignatureHeader, PeppolLookupResult, PeppolLookupStatus, ProviderDocument, ProviderDocumentLine, RegistryCompany, RetryPolicy, type RetryPolicyOptions, type RevenueCountryBreakdown, type RevenueCurrencyBreakdown, type RevenueStateBreakdown, RevenueStatistics, type RevenueStatisticsFilters, type RevenueTimeBucket, type RevenueTotals, type RevenueTypeBreakdown, ScoreBreakdown, SireneLookupResult, type SmartEnrichmentAddressQuality, type SmartEnrichmentConfidenceBucket, SmartEnrichmentEndpoint, type SmartEnrichmentExportOptions, type SmartEnrichmentHistoryInput, SmartEnrichmentHistoryPage, SmartEnrichmentHistoryRow, type SmartEnrichmentHistoryStats, type SmartEnrichmentInput, SmartEnrichmentJob, SmartEnrichmentMode, type SmartEnrichmentOfficialAddress, type SmartEnrichmentOutcomeBreakdown, type SmartEnrichmentProviderVerdict, SmartEnrichmentRecheck, type SmartEnrichmentRecheckOptions, type SmartEnrichmentRecheckRun, type SmartEnrichmentRecheckRunState, type SmartEnrichmentRecheckSkipReason, SmartEnrichmentRecheckState, type SmartEnrichmentRejectedCandidate, SmartEnrichmentRejectionReason, SmartEnrichmentResource, type SmartEnrichmentSourceBreakdown, SmartEnrichmentStatistics, type SmartEnrichmentStatisticsInterval, type SmartEnrichmentStatisticsOptions, type SmartEnrichmentStatisticsRange, type SmartEnrichmentStatisticsTotals, SmartEnrichmentStatus, type SmartEnrichmentTaxNumberSource, type SmartEnrichmentTimeBucket, type SmartEnrichmentUsage, type SmartEnrichmentUsageHistoryEntry, type SmartEnrichmentWaitOptions, TaxoraClient, TaxoraClientFactory, type TaxoraClientOptions, TaxoraException, type TaxoraWebhookEvent, type TestWebhookObject, Token, type TokenStorageInterface, type UpdateComplianceTransactionInput, ValidationException, VatCertificateExport, VatCollection, VatEndpoint, type VatRate, VatRates, VatResource, VatState, type VatStateChangedEvent, type VatValidatedEvent, VatValidationAddressInput, type VatWebhookObject, WEBHOOK_ID_HEADER, WEBHOOK_SIGNATURE_HEADER, type WebhookEventEnvelope, type WebhookEventType, type WebhookRawBody, type WebhookSignatureErrorReason, type WebhookSignatureHeaderInput, WebhookSignatureVerificationError, type WebhookTestEvent, type WebhookVerifyOptions, computeWebhookSignature, constructWebhookEvent, describeApiError, describeComplianceDocumentType, describeComplianceEnrollmentStatus, describeComplianceService, describeComplianceTaxReportState, describeComplianceTransactionState, describeComplianceTransactionType, describePeppolLookupStatus, describeSmartEnrichmentMode, describeSmartEnrichmentRejectionReason, describeSmartEnrichmentStatus, describeVatState, generateWebhookSignatureHeader, getBaseUrl, getFailedVatStates, parseLocalTaxNumbersCsv, parseWebhookSignatureHeader, toComplianceDocumentType, toComplianceEnrollmentStatus, toComplianceService, toComplianceTaxReportState, toComplianceTransactionState, toComplianceTransactionType, toPeppolLookupStatus, toSmartEnrichmentMode, toSmartEnrichmentRejectionReason, toSmartEnrichmentStatus, verifyWebhookSignature };
+export { ApiVersion, AuthEndpoint, AuthRetryHttpClient, AuthenticationException, BillingEndpoint, CompanyAddress, CompanyEndpoint, type CompanyResource, type ComplianceCheckoutConfirmation, type ComplianceCheckoutSession, type ComplianceCoverageCountry, ComplianceDeliveryAction, ComplianceDeliveryDecision, ComplianceDocumentType, ComplianceEnrollment, ComplianceEnrollmentPage, ComplianceEnrollmentStatus, type ComplianceEnterpriseSize, type ComplianceInvoiceLineInput, type ComplianceInvoicePdfFields, type ComplianceInvoicePdfInput, type ComplianceInvoiceTaxInput, type ComplianceLedgerStateChangedEvent, type ComplianceLedgerWebhookObject, type ComplianceNotificationDigest, type ComplianceNotificationSettings, type ComplianceOffering, type ComplianceOfferingPlan, ComplianceOfferings, type ComplianceRequestService, ComplianceService, ComplianceTax, ComplianceTaxCategory, ComplianceTaxReport, ComplianceTaxReportPage, type ComplianceTaxReportRequestState, ComplianceTaxReportState, ComplianceTransaction, type ComplianceTransactionBuyerInput, type ComplianceTransactionDeliveryCheck, type ComplianceTransactionDocument, type ComplianceTransactionEurEquivalent, type ComplianceTransactionExportFilters, type ComplianceTransactionFilters, type ComplianceTransactionInvoiceLine, type ComplianceTransactionInvoiceLineTax, type ComplianceTransactionInvoicePdf, ComplianceTransactionPage, type ComplianceTransactionRequestState, type ComplianceTransactionRequestType, ComplianceTransactionState, type ComplianceTransactionStateChangedEvent, ComplianceTransactionType, type ComplianceTransactionWebhookObject, type ComplianceTypeOperation, type CreateComplianceEnrollmentInput, type CreateComplianceTransactionInput, type CreateCreditNoteInput, type CreateNorwayEnrollmentInput, DEFAULT_WEBHOOK_TOLERANCE_SECONDS, EInvoicingQuota, EInvoicingQuotaPeriod, type EInvoicingQuotaTier, type EReportingAccessRequestInput, EReportingEndpoint, type EReportingInterval, type EnrichmentCompletedEvent, type EnrichmentCompletedWebhookObject, type EnrichmentUpdatedEvent, type EnrichmentUpdatedWebhookObject, Environment, Environment as EnvironmentType, FetchHttpClient, type HttpClientInterface, HttpException, ImportResult, InMemoryTokenStorage, type InvoiceTotals, type InvoiceTotalsOptions, Language, type LocalTaxNumberReportOptions, LocalTaxNumberRow, type LocalTaxNumberSummary, LoginIdentifier, type NorwayEnrollmentInput, NorwegianOrgNumber, type ParsedWebhookSignatureHeader, PeppolLookupResult, PeppolLookupStatus, ProviderDocument, ProviderDocumentLine, RegistryCompany, RetryPolicy, type RetryPolicyOptions, type RevenueCountryBreakdown, type RevenueCurrencyBreakdown, type RevenueStateBreakdown, RevenueStatistics, type RevenueStatisticsFilters, type RevenueTaxRatesCsvFilters, type RevenueTimeBucket, type RevenueTotals, type RevenueTypeBreakdown, ScoreBreakdown, SireneLookupResult, type SmartEnrichmentAddressQuality, type SmartEnrichmentConfidenceBucket, SmartEnrichmentEndpoint, type SmartEnrichmentExportOptions, type SmartEnrichmentHistoryInput, SmartEnrichmentHistoryPage, SmartEnrichmentHistoryRow, type SmartEnrichmentHistoryStats, type SmartEnrichmentInput, SmartEnrichmentJob, SmartEnrichmentMode, type SmartEnrichmentOfficialAddress, type SmartEnrichmentOutcomeBreakdown, type SmartEnrichmentProviderVerdict, SmartEnrichmentRecheck, type SmartEnrichmentRecheckOptions, type SmartEnrichmentRecheckRun, type SmartEnrichmentRecheckRunState, type SmartEnrichmentRecheckSkipReason, SmartEnrichmentRecheckState, type SmartEnrichmentRejectedCandidate, SmartEnrichmentRejectionReason, SmartEnrichmentResource, type SmartEnrichmentSourceBreakdown, SmartEnrichmentStatistics, type SmartEnrichmentStatisticsInterval, type SmartEnrichmentStatisticsOptions, type SmartEnrichmentStatisticsRange, type SmartEnrichmentStatisticsTotals, SmartEnrichmentStatus, type SmartEnrichmentTaxNumberSource, type SmartEnrichmentTimeBucket, type SmartEnrichmentUsage, type SmartEnrichmentUsageHistoryEntry, type SmartEnrichmentWaitOptions, TaxoraClient, TaxoraClientFactory, type TaxoraClientOptions, TaxoraException, type TaxoraWebhookEvent, type TestWebhookObject, Token, type TokenStorageInterface, type UpdateComplianceNotificationSettingsInput, type UpdateComplianceTransactionInput, type UsageEvent, UsageSummary, UsageSummaryPage, ValidationException, VatCertificateExport, VatCollection, VatEndpoint, type VatRate, VatRates, VatResource, VatState, type VatStateChangedEvent, type VatValidatedEvent, VatValidationAddressInput, type VatWebhookObject, WEBHOOK_ID_HEADER, WEBHOOK_SIGNATURE_HEADER, type WebhookEventEnvelope, type WebhookEventType, type WebhookRawBody, type WebhookSignatureErrorReason, type WebhookSignatureHeaderInput, WebhookSignatureVerificationError, type WebhookTestEvent, type WebhookVerifyOptions, calculateInvoiceTotals, computeWebhookSignature, constructWebhookEvent, describeApiError, describeComplianceDocumentType, describeComplianceEnrollmentStatus, describeComplianceService, describeComplianceTaxReportState, describeComplianceTransactionState, describeComplianceTransactionType, describePeppolLookupStatus, describeSmartEnrichmentMode, describeSmartEnrichmentRejectionReason, describeSmartEnrichmentStatus, describeVatState, generateWebhookSignatureHeader, getBaseUrl, getFailedVatStates, isTransactionBuyerRejected, parseComplianceTaxCategory, parseLocalTaxNumbersCsv, parseWebhookSignatureHeader, toComplianceDocumentType, toComplianceEnrollmentStatus, toComplianceService, toComplianceTaxReportState, toComplianceTransactionState, toComplianceTransactionType, toPeppolLookupStatus, toSmartEnrichmentMode, toSmartEnrichmentRejectionReason, toSmartEnrichmentStatus, verifyWebhookSignature };