@fleetless/contracts 6.2.0 → 6.3.0-next.1

package/dist/billing.d.ts

@@ -0,0 +1,778 @@
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+import { type AddonKey, type OrgAddons, type PlanCurrency, type PlanId } from './plans.js';
+/**
+ * Countries, VAT and the money math for billing through Mollie
+ * (fleetless/fleetless#104).
+ *
+ * Every price here reads from `plans.ts`'s `PLANS` / `ADDONS` catalogue,
+ * never a cent amount of its own, so a price change in one place is a price
+ * change everywhere. Money is integer cents throughout; the one rounding a
+ * proration or a VAT amount is allowed is `Math.round`, applied exactly
+ * once (`prorateCents`, `vatCents`, and `changeNetCents`'s single
+ * proration).
+ */
+/** ISO 3166-1 alpha-2, upper case. Greece is `GR` here; VIES calls it `EL`. */
+export declare const countryCode: z.ZodString;
+/** The 27 EU member states, as the billing country. Greece is `GR`. */
+export declare const EU_COUNTRIES: readonly ["AT", "BE", "BG", "CY", "CZ", "DE", "DK", "EE", "ES", "FI", "FR", "GR", "HR", "HU", "IE", "IT", "LT", "LU", "LV", "MT", "NL", "PL", "PT", "RO", "SE", "SI", "SK"];
+/** The seller: Dehne Robotik GmbH. Fleetless never charges another EU country's VAT. */
+export declare const SELLER_COUNTRY = "DE";
+/** Germany's VAT rate, in whole percent. */
+export declare const DE_VAT_RATE_PERCENT = 19;
+/** Whether `country` is one of the 27 EU member states. */
+export declare function isEuCountry(country: string): boolean;
+/** EUR in the EU, USD elsewhere. */
+export declare function currencyForCountry(country: string): PlanCurrency;
+/** Who is paying: a company (may hold a VAT ID) or a person (a full name, never a VAT ID). */
+export declare const payerKind: z.ZodEnum<{
+    company: "company";
+    person: "person";
+}>;
+export type PayerKind = z.infer<typeof payerKind>;
+/** The billing cycle: monthly, or yearly at twelve months for 15 % off (#103). */
+export declare const billingCycle: z.ZodEnum<{
+    monthly: "monthly";
+    yearly: "yearly";
+}>;
+export type BillingCycle = z.infer<typeof billingCycle>;
+/**
+ * How a charge is taxed: `de_standard` (German VAT), `reverse_charge` (0 %,
+ * an EU company whose VAT ID VIES confirms) or `outside_eu` (0 %, no
+ * reverse-charge note).
+ */
+export declare const vatTreatment: z.ZodEnum<{
+    de_standard: "de_standard";
+    reverse_charge: "reverse_charge";
+    outside_eu: "outside_eu";
+}>;
+export type VatTreatment = z.infer<typeof vatTreatment>;
+/**
+ * Why `vatFor` refused a payer: `eu_person` (a person outside Germany, in
+ * another EU country), `vat_id_required` (a company in another EU country
+ * gave no VAT ID) or `vat_id_invalid` (VIES said the given VAT ID is
+ * invalid).
+ */
+export declare const payerRefusalRule: z.ZodEnum<{
+    eu_person: "eu_person";
+    vat_id_required: "vat_id_required";
+    vat_id_invalid: "vat_id_invalid";
+}>;
+export type PayerRefusalRule = z.infer<typeof payerRefusalRule>;
+/** What `vatFor` decides: allowed with a treatment and rate, or refused with a rule. */
+export type VatDecision = {
+    allowed: true;
+    treatment: VatTreatment;
+    rate_percent: number;
+} | {
+    allowed: false;
+    rule: PayerRefusalRule;
+};
+/**
+ * Who may pay, and the VAT they pay. `vatIdValid`: `null` = no VAT ID
+ * given; `true` = VIES valid **or unverified** (VIES unreachable is
+ * accepted); `false` = VIES said invalid.
+ *
+ * Germany is unconditional — company or person, VAT ID optional, 19 %
+ * regardless of whether a given ID checks out. A German VAT ID's validity
+ * never gates checkout, only the renewal sweep later (dunning);
+ * `vatFor` only ever prices the charge in hand.
+ */
+export declare function vatFor(input: {
+    kind: PayerKind;
+    country: string;
+    vatIdValid: boolean | null;
+}): VatDecision;
+/** VIES's member-state code: `EL` for `GR`, the country otherwise. */
+export declare function viesCountry(country: string): string;
+/**
+ * Upper-case, without spaces, dots and dashes, and without a leading
+ * country prefix: the VIES code (`EL` for Greece) or, for Greece only, the
+ * address code `GR` as well, since a payer is as likely to type that. `null` for an
+ * empty string (trimmed).
+ */
+export declare function normalizeVatId(country: string, raw: string): string | null;
+/**
+ * Net price of one period: the plan plus each add-on × units, for the
+ * cycle and currency. Add-ons count only on Pro — `plans.ts`'s own rule for
+ * which plans may buy them at all (`planFeature.addons`). Throws for
+ * `enterprise`: its price is `null`, sold by contract, and self-service
+ * never charges it.
+ */
+export declare function periodNetCents(input: {
+    plan: PlanId;
+    addons: OrgAddons;
+    cycle: BillingCycle;
+    currency: PlanCurrency;
+}): number;
+/** `Math.round(priceCents * remainingDays / periodDays)` — the one rounding every proration in this module uses. */
+export declare function prorateCents(priceCents: number, remainingDays: number, periodDays: number): number;
+/** `Math.round(netCents * ratePercent / 100)`. */
+export declare function vatCents(netCents: number, ratePercent: number): number;
+/** One charge's amounts, in integer cents, excluding and including VAT. */
+export interface ChargeAmounts {
+    net_cents: number;
+    vat_cents: number;
+    gross_cents: number;
+}
+/** Net, VAT (`vatCents`) and gross for one charge. */
+export declare function chargeAmounts(netCents: number, ratePercent: number): ChargeAmounts;
+/** Milliseconds in a day. */
+export declare const DAY_MS = 86400000;
+/** Whole days between `start` and `end` (`Math.round`). */
+export declare function periodDays(start: Date, end: Date): number;
+/** Days left until `end`, as of `now` (`Math.ceil`), clamped to `[0, days]`. */
+export declare function remainingDays(now: Date, end: Date, days: number): number;
+/** A billing state: plan, add-ons and cycle — enough to price one period, or compare two for `changeNetCents`. */
+export interface BillingState {
+    plan: PlanId;
+    addons: OrgAddons;
+    cycle: BillingCycle;
+}
+/**
+ * The net amount charged NOW for moving `from` → `to` within the period
+ * — increases are charged at once, decreases wait for the period's end,
+ * nothing is credited. Three branches, in this order:
+ *
+ * 1. **Monthly → yearly**: the full yearly price of `to` (plan plus
+ *    add-ons, Pro only) minus the unused share of `from`'s monthly price,
+ *    floored at 0. The period restarts today with a new anchor, so this
+ *    is the only branch that prices `to` and `from` on different cycles.
+ * 2. **Yearly → monthly**: the reverse is a cycle *decrease* — charged 0
+ *    now, stored as `next_cycle` and applied at the period's end, like
+ *    every other decrease.
+ * 3. **Same cycle**: the increase only — the plan difference when `to` is
+ *    the higher plan (`PLAN_ORDER`), plus each add-on's added units × its
+ *    unit price, summed and prorated once over the remaining days. A plan
+ *    decrease and fewer add-ons contribute 0; add-ons count only when
+ *    `to.plan` is `pro`, and units held on a plan other than Pro count as
+ *    none.
+ */
+export declare function changeNetCents(input: {
+    from: BillingState;
+    to: BillingState;
+    currency: PlanCurrency;
+    periodStart: Date;
+    periodEnd: Date;
+    now: Date;
+}): number;
+/** One line of a `CheckoutQuote`: the plan, or one add-on, with its quantity and both amounts. */
+export interface QuoteLine {
+    item: 'plan' | AddonKey;
+    quantity: number;
+    net_cents: number;
+    gross_cents: number;
+}
+/** The first charge of a checkout, broken into lines, in the cycle and currency it is quoted in. */
+export interface CheckoutQuote extends ChargeAmounts {
+    lines: QuoteLine[];
+    rate_percent: number;
+    currency: PlanCurrency;
+    cycle: BillingCycle;
+}
+/**
+ * The first charge of a checkout: one full period of `plan` + `addons`.
+ * One line for the plan, then one line per add-on actually bought
+ * (quantity 0 is omitted, not a zero-amount line).
+ */
+export declare function checkoutQuote(input: {
+    plan: 'plus' | 'pro';
+    addons: OrgAddons;
+    cycle: BillingCycle;
+    currency: PlanCurrency;
+    rate_percent: number;
+}): CheckoutQuote;
+/** Dunning after a failed renewal: retries on these days after the charge's due date. */
+export declare const BILLING_RETRY_DAYS: readonly [3, 7];
+/** The day, after the charge's due date, the org is locked when still unpaid. */
+export declare const BILLING_LOCK_DAY = 14;
+/** A billing address. `country` gates VAT (`vatFor`) and currency (`currencyForCountry`). */
+export declare const billingAddress: z.ZodObject<{
+    line1: z.ZodString;
+    line2: z.ZodNullable<z.ZodString>;
+    postal_code: z.ZodString;
+    city: z.ZodString;
+    country: z.ZodString;
+}, z.core.$strict>;
+export type BillingAddress = z.infer<typeof billingAddress>;
+/**
+ * Who is paying: a `company` (may hold a VAT
+ * ID, checked through VIES) or a `person` (full name, never a VAT ID — only
+ * a company can be VAT-registered). The discriminant decides which other
+ * fields exist at all, so a person cannot even send `vat_id` or
+ * `company_name` — there is no field for `.strict()` to refuse, the shape
+ * itself has none.
+ */
+export declare const billingDetails: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"company">;
+    company_name: z.ZodString;
+    vat_id: z.ZodNullable<z.ZodString>;
+    address: z.ZodObject<{
+        line1: z.ZodString;
+        line2: z.ZodNullable<z.ZodString>;
+        postal_code: z.ZodString;
+        city: z.ZodString;
+        country: z.ZodString;
+    }, z.core.$strict>;
+    invoice_email: z.ZodEmail;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"person">;
+    full_name: z.ZodString;
+    address: z.ZodObject<{
+        line1: z.ZodString;
+        line2: z.ZodNullable<z.ZodString>;
+        postal_code: z.ZodString;
+        city: z.ZodString;
+        country: z.ZodString;
+    }, z.core.$strict>;
+    invoice_email: z.ZodEmail;
+}, z.core.$strict>], "kind">;
+export type BillingDetails = z.infer<typeof billingDetails>;
+/**
+ * `POST /api/billing/checkout`'s body: the plan and cycle to buy — Basic is
+ * free and never checked out — optional add-ons (Pro only; named on `plus`,
+ * or without `planFeature.addons`, is `400 validation_error`), the payer,
+ * and the terms and withdrawal confirmations: `accept_terms` is
+ * always required; `accept_withdrawal` is required for a person and refused
+ * for a company, which has no consumer right of withdrawal to confirm.
+ */
+export declare const checkoutRequest: z.ZodObject<{
+    plan: z.ZodEnum<{
+        plus: "plus";
+        pro: "pro";
+    }>;
+    cycle: z.ZodEnum<{
+        monthly: "monthly";
+        yearly: "yearly";
+    }>;
+    addons: z.ZodOptional<z.ZodObject<{
+        seats: z.ZodOptional<z.ZodNumber>;
+        robots: z.ZodOptional<z.ZodNumber>;
+        apps: z.ZodOptional<z.ZodNumber>;
+        app_user_packs: z.ZodOptional<z.ZodNumber>;
+        live_video_packs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    billing: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"company">;
+        company_name: z.ZodString;
+        vat_id: z.ZodNullable<z.ZodString>;
+        address: z.ZodObject<{
+            line1: z.ZodString;
+            line2: z.ZodNullable<z.ZodString>;
+            postal_code: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>;
+        invoice_email: z.ZodEmail;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"person">;
+        full_name: z.ZodString;
+        address: z.ZodObject<{
+            line1: z.ZodString;
+            line2: z.ZodNullable<z.ZodString>;
+            postal_code: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>;
+        invoice_email: z.ZodEmail;
+    }, z.core.$strict>], "kind">;
+    accept_terms: z.ZodLiteral<true>;
+    accept_withdrawal: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type CheckoutRequest = z.infer<typeof checkoutRequest>;
+/** `POST /api/billing/checkout`'s answer: where to send the caller's browser. */
+export declare const checkoutResponse: z.ZodObject<{
+    checkout_id: z.ZodUUID;
+    checkout_url: z.ZodURL;
+}, z.core.$strip>;
+export type CheckoutResponse = z.infer<typeof checkoutResponse>;
+/** `GET /api/billing/checkout/:id`'s answer: the return page's poll. */
+export declare const checkoutStatus: z.ZodObject<{
+    checkout_id: z.ZodUUID;
+    status: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        paid: "paid";
+        canceled: "canceled";
+        expired: "expired";
+    }>;
+    purpose: z.ZodEnum<{
+        upgrade: "upgrade";
+        payment_method: "payment_method";
+        invoice: "invoice";
+    }>;
+    plan: z.ZodEnum<{
+        basic: "basic";
+        plus: "plus";
+        pro: "pro";
+        enterprise: "enterprise";
+    }>;
+}, z.core.$strip>;
+export type CheckoutStatus = z.infer<typeof checkoutStatus>;
+/** VIES's answer to a VAT-ID check: `unverified` when VIES could not be reached in time. */
+export declare const vatIdStatus: z.ZodEnum<{
+    valid: "valid";
+    unverified: "unverified";
+    invalid: "invalid";
+}>;
+export type VatIdStatus = z.infer<typeof vatIdStatus>;
+/** `POST /api/billing/vat-id/check`'s body: the VAT-ID-on-blur check the checkout and `PATCH /api/billing/details` both use. */
+export declare const vatIdCheckRequest: z.ZodObject<{
+    country: z.ZodString;
+    vat_id: z.ZodString;
+}, z.core.$strict>;
+export type VatIdCheckRequest = z.infer<typeof vatIdCheckRequest>;
+/** `POST /api/billing/vat-id/check`'s answer. */
+export declare const vatIdCheckResponse: z.ZodObject<{
+    status: z.ZodEnum<{
+        valid: "valid";
+        unverified: "unverified";
+        invalid: "invalid";
+    }>;
+    vat_id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type VatIdCheckResponse = z.infer<typeof vatIdCheckResponse>;
+/**
+ * `POST /api/billing/change`'s body: the **absolute** target state, never a
+ * delta — the route compares it with the org's current state
+ * and splits the difference into what is charged now and what is only
+ * scheduled. At least one of `plan`, `cycle` or `addons` must be named; the
+ * `.refine()` below says so in prose rather than in the JSON Schema this
+ * exports as, the same discipline `auditQuery`'s pair already follows —
+ * `.refine()` has no JSON Schema rendering.
+ */
+export declare const billingChangeRequest: z.ZodObject<{
+    plan: z.ZodOptional<z.ZodEnum<{
+        plus: "plus";
+        pro: "pro";
+    }>>;
+    cycle: z.ZodOptional<z.ZodEnum<{
+        monthly: "monthly";
+        yearly: "yearly";
+    }>>;
+    addons: z.ZodOptional<z.ZodObject<{
+        seats: z.ZodOptional<z.ZodNumber>;
+        robots: z.ZodOptional<z.ZodNumber>;
+        apps: z.ZodOptional<z.ZodNumber>;
+        app_user_packs: z.ZodOptional<z.ZodNumber>;
+        live_video_packs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BillingChangeRequest = z.infer<typeof billingChangeRequest>;
+/** `POST /api/billing/cancel`'s body — optional, hence `requestOptional` on the route entry. */
+export declare const billingCancelRequest: z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BillingCancelRequest = z.infer<typeof billingCancelRequest>;
+/** `PATCH /api/billing/details`'s body: the invoice email and the VAT ID, the two fields an owner edits after checkout. */
+export declare const billingDetailsUpdate: z.ZodObject<{
+    invoice_email: z.ZodOptional<z.ZodEmail>;
+    vat_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type BillingDetailsUpdate = z.infer<typeof billingDetailsUpdate>;
+/** `POST /api/billing/payment-method`'s body. */
+export declare const paymentMethodChangeRequest: z.ZodObject<{
+    method: z.ZodEnum<{
+        card: "card";
+        paypal: "paypal";
+        sepa: "sepa";
+    }>;
+}, z.core.$strict>;
+export type PaymentMethodChangeRequest = z.infer<typeof paymentMethodChangeRequest>;
+/** The billing account's own status, distinct from the org's plan: `billing_accounts` holds no plan, currency or period of its own. */
+export declare const billingAccountStatus: z.ZodEnum<{
+    active: "active";
+    pending: "pending";
+    canceled: "canceled";
+    past_due: "past_due";
+}>;
+export type BillingAccountStatus = z.infer<typeof billingAccountStatus>;
+/** The payment method on file, read from the active Mollie mandate — never a card or bank number, only its display fields. */
+export declare const paymentMethod: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"card">;
+    brand: z.ZodString;
+    last4: z.ZodString;
+    expires: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sepa">;
+    holder: z.ZodString;
+    iban_last4: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"paypal">;
+    account: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type PaymentMethod = z.infer<typeof paymentMethod>;
+/** An invoice's status: `open` until paid, or `uncollectible` after a fallback to Basic with an unpaid balance. */
+export declare const invoiceStatus: z.ZodEnum<{
+    paid: "paid";
+    open: "open";
+    uncollectible: "uncollectible";
+}>;
+export type InvoiceStatus = z.infer<typeof invoiceStatus>;
+/** One invoice, rendered by the cloud: the number is gapless, `FL-<year>-<seq>`. */
+export declare const billingInvoice: z.ZodObject<{
+    id: z.ZodUUID;
+    number: z.ZodString;
+    issued_at: z.ZodISODateTime;
+    status: z.ZodEnum<{
+        paid: "paid";
+        open: "open";
+        uncollectible: "uncollectible";
+    }>;
+    currency: z.ZodEnum<{
+        eur: "eur";
+        usd: "usd";
+    }>;
+    net_cents: z.ZodNumber;
+    vat_rate_percent: z.ZodNumber;
+    vat_cents: z.ZodNumber;
+    gross_cents: z.ZodNumber;
+}, z.core.$strip>;
+export type BillingInvoice = z.infer<typeof billingInvoice>;
+/**
+ * The org's billing account: the payer, the VAT treatment, the cycle and
+ * period, what is scheduled for the period's end and dunning
+ *, when a charge is overdue. `orgs.plan`, `orgs.currency` and
+ * `orgs.period_ends_at` stay the single source of truth for the plan itself
+ * (#103) — nothing here duplicates them.
+ */
+export declare const billingAccount: z.ZodObject<{
+    payer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"company">;
+        company_name: z.ZodString;
+        vat_id: z.ZodNullable<z.ZodString>;
+        address: z.ZodObject<{
+            line1: z.ZodString;
+            line2: z.ZodNullable<z.ZodString>;
+            postal_code: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>;
+        invoice_email: z.ZodEmail;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"person">;
+        full_name: z.ZodString;
+        address: z.ZodObject<{
+            line1: z.ZodString;
+            line2: z.ZodNullable<z.ZodString>;
+            postal_code: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>;
+        invoice_email: z.ZodEmail;
+    }, z.core.$strict>], "kind">;
+    vat_id_status: z.ZodNullable<z.ZodEnum<{
+        valid: "valid";
+        unverified: "unverified";
+        invalid: "invalid";
+    }>>;
+    vat: z.ZodObject<{
+        treatment: z.ZodEnum<{
+            de_standard: "de_standard";
+            reverse_charge: "reverse_charge";
+            outside_eu: "outside_eu";
+        }>;
+        rate_percent: z.ZodNumber;
+    }, z.core.$strip>;
+    currency: z.ZodEnum<{
+        eur: "eur";
+        usd: "usd";
+    }>;
+    cycle: z.ZodEnum<{
+        monthly: "monthly";
+        yearly: "yearly";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        pending: "pending";
+        canceled: "canceled";
+        past_due: "past_due";
+    }>;
+    period_starts_at: z.ZodNullable<z.ZodISODateTime>;
+    period_ends_at: z.ZodNullable<z.ZodISODateTime>;
+    next_charge: z.ZodNullable<z.ZodObject<{
+        at: z.ZodISODateTime;
+        net_cents: z.ZodNumber;
+        vat_cents: z.ZodNumber;
+        gross_cents: z.ZodNumber;
+    }, z.core.$strip>>;
+    scheduled: z.ZodObject<{
+        cycle: z.ZodNullable<z.ZodEnum<{
+            monthly: "monthly";
+            yearly: "yearly";
+        }>>;
+        addons: z.ZodNullable<z.ZodObject<{
+            seats: z.ZodNumber;
+            robots: z.ZodNumber;
+            apps: z.ZodNumber;
+            app_user_packs: z.ZodNumber;
+            live_video_packs: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    dunning: z.ZodNullable<z.ZodObject<{
+        invoice_id: z.ZodUUID;
+        gross_cents: z.ZodNumber;
+        due_at: z.ZodISODateTime;
+        next_retry_at: z.ZodNullable<z.ZodISODateTime>;
+        lock_at: z.ZodISODateTime;
+        failure: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BillingAccount = z.infer<typeof billingAccount>;
+/** `GET /api/billing`'s answer, and what every other billing route hands back after a change. */
+export declare const billingView: z.ZodObject<{
+    available: z.ZodBoolean;
+    account: z.ZodNullable<z.ZodObject<{
+        payer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"company">;
+            company_name: z.ZodString;
+            vat_id: z.ZodNullable<z.ZodString>;
+            address: z.ZodObject<{
+                line1: z.ZodString;
+                line2: z.ZodNullable<z.ZodString>;
+                postal_code: z.ZodString;
+                city: z.ZodString;
+                country: z.ZodString;
+            }, z.core.$strict>;
+            invoice_email: z.ZodEmail;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"person">;
+            full_name: z.ZodString;
+            address: z.ZodObject<{
+                line1: z.ZodString;
+                line2: z.ZodNullable<z.ZodString>;
+                postal_code: z.ZodString;
+                city: z.ZodString;
+                country: z.ZodString;
+            }, z.core.$strict>;
+            invoice_email: z.ZodEmail;
+        }, z.core.$strict>], "kind">;
+        vat_id_status: z.ZodNullable<z.ZodEnum<{
+            valid: "valid";
+            unverified: "unverified";
+            invalid: "invalid";
+        }>>;
+        vat: z.ZodObject<{
+            treatment: z.ZodEnum<{
+                de_standard: "de_standard";
+                reverse_charge: "reverse_charge";
+                outside_eu: "outside_eu";
+            }>;
+            rate_percent: z.ZodNumber;
+        }, z.core.$strip>;
+        currency: z.ZodEnum<{
+            eur: "eur";
+            usd: "usd";
+        }>;
+        cycle: z.ZodEnum<{
+            monthly: "monthly";
+            yearly: "yearly";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            pending: "pending";
+            canceled: "canceled";
+            past_due: "past_due";
+        }>;
+        period_starts_at: z.ZodNullable<z.ZodISODateTime>;
+        period_ends_at: z.ZodNullable<z.ZodISODateTime>;
+        next_charge: z.ZodNullable<z.ZodObject<{
+            at: z.ZodISODateTime;
+            net_cents: z.ZodNumber;
+            vat_cents: z.ZodNumber;
+            gross_cents: z.ZodNumber;
+        }, z.core.$strip>>;
+        scheduled: z.ZodObject<{
+            cycle: z.ZodNullable<z.ZodEnum<{
+                monthly: "monthly";
+                yearly: "yearly";
+            }>>;
+            addons: z.ZodNullable<z.ZodObject<{
+                seats: z.ZodNumber;
+                robots: z.ZodNumber;
+                apps: z.ZodNumber;
+                app_user_packs: z.ZodNumber;
+                live_video_packs: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        dunning: z.ZodNullable<z.ZodObject<{
+            invoice_id: z.ZodUUID;
+            gross_cents: z.ZodNumber;
+            due_at: z.ZodISODateTime;
+            next_retry_at: z.ZodNullable<z.ZodISODateTime>;
+            lock_at: z.ZodISODateTime;
+            failure: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    payment_method: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"card">;
+        brand: z.ZodString;
+        last4: z.ZodString;
+        expires: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sepa">;
+        holder: z.ZodString;
+        iban_last4: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"paypal">;
+        account: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    invoices: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        number: z.ZodString;
+        issued_at: z.ZodISODateTime;
+        status: z.ZodEnum<{
+            paid: "paid";
+            open: "open";
+            uncollectible: "uncollectible";
+        }>;
+        currency: z.ZodEnum<{
+            eur: "eur";
+            usd: "usd";
+        }>;
+        net_cents: z.ZodNumber;
+        vat_rate_percent: z.ZodNumber;
+        vat_cents: z.ZodNumber;
+        gross_cents: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BillingView = z.infer<typeof billingView>;
+/** `POST /api/billing/change`'s answer: the billing view afterwards, and what was charged right now, if anything. */
+export declare const billingChangeResponse: z.ZodObject<{
+    billing: z.ZodObject<{
+        available: z.ZodBoolean;
+        account: z.ZodNullable<z.ZodObject<{
+            payer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"company">;
+                company_name: z.ZodString;
+                vat_id: z.ZodNullable<z.ZodString>;
+                address: z.ZodObject<{
+                    line1: z.ZodString;
+                    line2: z.ZodNullable<z.ZodString>;
+                    postal_code: z.ZodString;
+                    city: z.ZodString;
+                    country: z.ZodString;
+                }, z.core.$strict>;
+                invoice_email: z.ZodEmail;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"person">;
+                full_name: z.ZodString;
+                address: z.ZodObject<{
+                    line1: z.ZodString;
+                    line2: z.ZodNullable<z.ZodString>;
+                    postal_code: z.ZodString;
+                    city: z.ZodString;
+                    country: z.ZodString;
+                }, z.core.$strict>;
+                invoice_email: z.ZodEmail;
+            }, z.core.$strict>], "kind">;
+            vat_id_status: z.ZodNullable<z.ZodEnum<{
+                valid: "valid";
+                unverified: "unverified";
+                invalid: "invalid";
+            }>>;
+            vat: z.ZodObject<{
+                treatment: z.ZodEnum<{
+                    de_standard: "de_standard";
+                    reverse_charge: "reverse_charge";
+                    outside_eu: "outside_eu";
+                }>;
+                rate_percent: z.ZodNumber;
+            }, z.core.$strip>;
+            currency: z.ZodEnum<{
+                eur: "eur";
+                usd: "usd";
+            }>;
+            cycle: z.ZodEnum<{
+                monthly: "monthly";
+                yearly: "yearly";
+            }>;
+            status: z.ZodEnum<{
+                active: "active";
+                pending: "pending";
+                canceled: "canceled";
+                past_due: "past_due";
+            }>;
+            period_starts_at: z.ZodNullable<z.ZodISODateTime>;
+            period_ends_at: z.ZodNullable<z.ZodISODateTime>;
+            next_charge: z.ZodNullable<z.ZodObject<{
+                at: z.ZodISODateTime;
+                net_cents: z.ZodNumber;
+                vat_cents: z.ZodNumber;
+                gross_cents: z.ZodNumber;
+            }, z.core.$strip>>;
+            scheduled: z.ZodObject<{
+                cycle: z.ZodNullable<z.ZodEnum<{
+                    monthly: "monthly";
+                    yearly: "yearly";
+                }>>;
+                addons: z.ZodNullable<z.ZodObject<{
+                    seats: z.ZodNumber;
+                    robots: z.ZodNumber;
+                    apps: z.ZodNumber;
+                    app_user_packs: z.ZodNumber;
+                    live_video_packs: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            dunning: z.ZodNullable<z.ZodObject<{
+                invoice_id: z.ZodUUID;
+                gross_cents: z.ZodNumber;
+                due_at: z.ZodISODateTime;
+                next_retry_at: z.ZodNullable<z.ZodISODateTime>;
+                lock_at: z.ZodISODateTime;
+                failure: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        payment_method: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"card">;
+            brand: z.ZodString;
+            last4: z.ZodString;
+            expires: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"sepa">;
+            holder: z.ZodString;
+            iban_last4: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"paypal">;
+            account: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        invoices: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            number: z.ZodString;
+            issued_at: z.ZodISODateTime;
+            status: z.ZodEnum<{
+                paid: "paid";
+                open: "open";
+                uncollectible: "uncollectible";
+            }>;
+            currency: z.ZodEnum<{
+                eur: "eur";
+                usd: "usd";
+            }>;
+            net_cents: z.ZodNumber;
+            vat_rate_percent: z.ZodNumber;
+            vat_cents: z.ZodNumber;
+            gross_cents: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    charged: z.ZodNullable<z.ZodObject<{
+        id: z.ZodUUID;
+        number: z.ZodString;
+        issued_at: z.ZodISODateTime;
+        status: z.ZodEnum<{
+            paid: "paid";
+            open: "open";
+            uncollectible: "uncollectible";
+        }>;
+        currency: z.ZodEnum<{
+            eur: "eur";
+            usd: "usd";
+        }>;
+        net_cents: z.ZodNumber;
+        vat_rate_percent: z.ZodNumber;
+        vat_cents: z.ZodNumber;
+        gross_cents: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BillingChangeResponse = z.infer<typeof billingChangeResponse>;