@oxyhq/contracts 0.26.0 → 0.28.0

package/dist/types/inference/accountBilling.d.ts

@@ -0,0 +1,738 @@
+/**
+ * The account-scoped billing surface: who pays, what they hold, what bounds
+ * them, and how it reconciles against the payment processor.
+ *
+ * Every shape here is denominated in {@link exactDecimalSchema} — an exact
+ * decimal string — for the reason `money.ts` gives at length: a JS `number`
+ * cannot represent `0.1 + 0.2`, and a balance is the last place a rounding error
+ * should be allowed to accumulate silently.
+ *
+ * ## What is NOT here, and where it is instead
+ *
+ * The BALANCE and the BUDGETS both live at `/inference/reporting` (#972
+ * workstream 8), which owns the customer's view of what they hold and what
+ * bounds them, stamped `{source, consistency}` so a reader can always tell which
+ * kind of number they are looking at. This file declares who PAYS and on what
+ * TERMS, plus the records that sit behind those numbers — invoices, processor
+ * payments, auto-recharge attempts and reconciliation.
+ *
+ * The split is not cosmetic. A second balance shape here would be a second
+ * answer to one question, and the pair would disagree the day one of them stops
+ * accounting for an invoiced account's unused credit line — which is exactly the
+ * kind of drift a customer discovers before we do.
+ *
+ * ## Product entitlements are NOT here
+ *
+ * Alia plans, their monthly allowances and the API-credit product live in
+ * `entitlement.ts`, in a shape that cannot be added to a balance. #972 is
+ * explicit that confusing a product subscription with pay-as-you-go inference
+ * spend is the failure mode, so the two are separate types that share no field
+ * and no unit.
+ *
+ * ## Stripe appears only as a REFERENCE
+ *
+ * `externalRef` names a record in the processor's database; nothing in this file
+ * is derived from Stripe, and no shape here can carry a processor-computed
+ * balance. The epic's invariant is that Stripe is a payment and invoicing
+ * processor and not the authoritative usage ledger, so the reconciliation shapes
+ * below describe a COMPARISON between two independent records rather than an
+ * import of one into the other.
+ *
+ * Decided in: docs/adr/0014-account-billing-and-entitlements.md,
+ * docs/adr/0009-usage-reservation-and-settlement.md.
+ */
+import { z } from 'zod';
+/**
+ * How an account pays.
+ *
+ * `prepaid` spends money it topped up in advance. `invoiced` draws against a
+ * credit limit and is billed in arrears — the enterprise shape. Both settle
+ * through the same ledger; the difference is only which bucket a reservation
+ * draws from once the prepaid and granted balances are exhausted.
+ */
+export declare const BILLING_MODES: readonly ["prepaid", "invoiced"];
+export declare const billingModeSchema: z.ZodEnum<["prepaid", "invoiced"]>;
+/** Whether the profile may currently spend at all. */
+export declare const BILLING_PROFILE_STATUSES: readonly ["active", "suspended", "closed"];
+export declare const billingProfileStatusSchema: z.ZodEnum<["active", "suspended", "closed"]>;
+/**
+ * Automatic top-up settings.
+ *
+ * An IMPLICATION rather than a biconditional, matching the column CHECK: the
+ * two amounts may be configured before the feature is switched on, but an
+ * `enabled` recharge with either missing is a setting that reads as "on" and can
+ * never fire — the shape a customer discovers only when their traffic stops.
+ */
+export declare const autoRechargeSchema: z.ZodEffects<z.ZodObject<{
+    enabled: z.ZodBoolean;
+    /** Recharge when the spendable balance falls below this. */
+    threshold: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+    /** How much to add. */
+    amount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+}, "strict", z.ZodTypeAny, {
+    enabled: boolean;
+    amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+}, {
+    enabled: boolean;
+    amount?: string | undefined;
+    threshold?: string | undefined;
+}>, {
+    enabled: boolean;
+    amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+}, {
+    enabled: boolean;
+    amount?: string | undefined;
+    threshold?: string | undefined;
+}>;
+/**
+ * Which account pays for a workload, and on what terms.
+ *
+ * `accountId` is an Oxy account of ANY kind — personal, organization, project,
+ * bot or channel — because `Application.ownerAccountId` may be any of them. It
+ * is branded (`oxyAccountIdSchema`), so a delegated end-user id cannot be
+ * substituted for it anywhere in this contract.
+ */
+export declare const billingProfileSchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    accountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    currency: z.ZodString;
+    billingMode: z.ZodEnum<["prepaid", "invoiced"]>;
+    status: z.ZodEnum<["active", "suspended", "closed"]>;
+    /**
+     * How far an `invoiced` account may draw before a reservation is refused.
+     * Always `'0'` for a `prepaid` account, where it is not consulted at all.
+     */
+    creditLimit: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    autoRecharge: z.ZodEffects<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        /** Recharge when the spendable balance falls below this. */
+        threshold: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+        /** How much to add. */
+        amount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+    }, "strict", z.ZodTypeAny, {
+        enabled: boolean;
+        amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    }, {
+        enabled: boolean;
+        amount?: string | undefined;
+        threshold?: string | undefined;
+    }>, {
+        enabled: boolean;
+        amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    }, {
+        enabled: boolean;
+        amount?: string | undefined;
+        threshold?: string | undefined;
+    }>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "active" | "suspended" | "closed";
+    accountId: string & z.BRAND<"OxyAccountId">;
+    updatedAt: string;
+    createdAt: string;
+    currency: string;
+    schemaVersion: 1;
+    billingMode: "prepaid" | "invoiced";
+    creditLimit: string & z.BRAND<"ExactDecimal">;
+    autoRecharge: {
+        enabled: boolean;
+        amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    };
+}, {
+    status: "active" | "suspended" | "closed";
+    accountId: string;
+    updatedAt: string;
+    createdAt: string;
+    currency: string;
+    schemaVersion: 1;
+    billingMode: "prepaid" | "invoiced";
+    creditLimit: string;
+    autoRecharge: {
+        enabled: boolean;
+        amount?: string | undefined;
+        threshold?: string | undefined;
+    };
+}>;
+/**
+ * WHO pays for an account and on what TERMS. Deliberately not how much they
+ * have.
+ *
+ * The balance lives at `GET /inference/reporting/accounts/:accountId/balance`
+ * (#972 workstream 8), which reads `account_balances` and stamps every response
+ * with `{source: 'financial_ledger', consistency: 'authoritative'}`. Restating
+ * those amounts here would be a second answer to one question, and the failure
+ * mode of two balance endpoints is the pair disagreeing on the day one of them
+ * stops accounting for the credit line.
+ *
+ * What this shape adds, and what nothing else carries: `billingAccountId` and
+ * `inherited`. A project draws on the nearest ancestor that has a profile
+ * (ADR 0014), so a Console page has to be able to say "this project spends the
+ * organization's balance" — showing somebody else's money under a project's name
+ * with no indication whose it is would be worse than showing nothing.
+ */
+export declare const accountBillingStateSchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    accountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    billingAccountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    inherited: z.ZodBoolean;
+    profile: z.ZodObject<{
+        /** See `version.ts`: this shape is served to Console and to Alia. */
+        schemaVersion: z.ZodLiteral<1>;
+        accountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+        currency: z.ZodString;
+        billingMode: z.ZodEnum<["prepaid", "invoiced"]>;
+        status: z.ZodEnum<["active", "suspended", "closed"]>;
+        /**
+         * How far an `invoiced` account may draw before a reservation is refused.
+         * Always `'0'` for a `prepaid` account, where it is not consulted at all.
+         */
+        creditLimit: z.ZodBranded<z.ZodString, "ExactDecimal">;
+        autoRecharge: z.ZodEffects<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            /** Recharge when the spendable balance falls below this. */
+            threshold: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+            /** How much to add. */
+            amount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+        }, "strict", z.ZodTypeAny, {
+            enabled: boolean;
+            amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+            threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        }, {
+            enabled: boolean;
+            amount?: string | undefined;
+            threshold?: string | undefined;
+        }>, {
+            enabled: boolean;
+            amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+            threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        }, {
+            enabled: boolean;
+            amount?: string | undefined;
+            threshold?: string | undefined;
+        }>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        status: "active" | "suspended" | "closed";
+        accountId: string & z.BRAND<"OxyAccountId">;
+        updatedAt: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        billingMode: "prepaid" | "invoiced";
+        creditLimit: string & z.BRAND<"ExactDecimal">;
+        autoRecharge: {
+            enabled: boolean;
+            amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+            threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        };
+    }, {
+        status: "active" | "suspended" | "closed";
+        accountId: string;
+        updatedAt: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        billingMode: "prepaid" | "invoiced";
+        creditLimit: string;
+        autoRecharge: {
+            enabled: boolean;
+            amount?: string | undefined;
+            threshold?: string | undefined;
+        };
+    }>;
+}, "strict", z.ZodTypeAny, {
+    accountId: string & z.BRAND<"OxyAccountId">;
+    profile: {
+        status: "active" | "suspended" | "closed";
+        accountId: string & z.BRAND<"OxyAccountId">;
+        updatedAt: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        billingMode: "prepaid" | "invoiced";
+        creditLimit: string & z.BRAND<"ExactDecimal">;
+        autoRecharge: {
+            enabled: boolean;
+            amount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+            threshold?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        };
+    };
+    schemaVersion: 1;
+    billingAccountId: string & z.BRAND<"OxyAccountId">;
+    inherited: boolean;
+}, {
+    accountId: string;
+    profile: {
+        status: "active" | "suspended" | "closed";
+        accountId: string;
+        updatedAt: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        billingMode: "prepaid" | "invoiced";
+        creditLimit: string;
+        autoRecharge: {
+            enabled: boolean;
+            amount?: string | undefined;
+            threshold?: string | undefined;
+        };
+    };
+    schemaVersion: 1;
+    billingAccountId: string;
+    inherited: boolean;
+}>;
+export declare const BILLING_INVOICE_STATUSES: readonly ["draft", "open", "paid", "void"];
+export declare const billingInvoiceStatusSchema: z.ZodEnum<["draft", "open", "paid", "void"]>;
+/**
+ * A period's charges, aggregated — the invoiced-enterprise settlement document.
+ *
+ * `subtotalAmount` is the EXACT sum of the receipts on the invoice, at full
+ * scale; `totalAmount` is the rounded figure actually charged. The difference is
+ * booked as an `invoice_rounding` ledger entry rather than discarded, because a
+ * discarded remainder is money that exists in one system and not the other.
+ *
+ * `minorUnitExponent` is carried rather than derived from the currency code:
+ * USD is 2, JPY is 0, BHD is 3, and that is not a property this platform's
+ * database knows. Storing what was used keeps the invoice reproducible.
+ */
+export declare const billingInvoiceSchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    accountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    currency: z.ZodString;
+    periodStart: z.ZodString;
+    periodEnd: z.ZodString;
+    status: z.ZodEnum<["draft", "open", "paid", "void"]>;
+    subtotalAmount: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    totalAmount: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    minorUnitExponent: z.ZodNumber;
+    /** The processor's own invoice id, for reconciliation. Never an authority. */
+    externalInvoiceRef: z.ZodOptional<z.ZodString>;
+    issuedAt: z.ZodOptional<z.ZodString>;
+    paidAt: z.ZodOptional<z.ZodString>;
+    receiptCount: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    status: "void" | "open" | "draft" | "paid";
+    accountId: string & z.BRAND<"OxyAccountId">;
+    id: string;
+    periodEnd: string;
+    currency: string;
+    schemaVersion: 1;
+    periodStart: string;
+    subtotalAmount: string & z.BRAND<"ExactDecimal">;
+    totalAmount: string & z.BRAND<"ExactDecimal">;
+    minorUnitExponent: number;
+    receiptCount: number;
+    issuedAt?: string | undefined;
+    externalInvoiceRef?: string | undefined;
+    paidAt?: string | undefined;
+}, {
+    status: "void" | "open" | "draft" | "paid";
+    accountId: string;
+    id: string;
+    periodEnd: string;
+    currency: string;
+    schemaVersion: 1;
+    periodStart: string;
+    subtotalAmount: string;
+    totalAmount: string;
+    minorUnitExponent: number;
+    receiptCount: number;
+    issuedAt?: string | undefined;
+    externalInvoiceRef?: string | undefined;
+    paidAt?: string | undefined;
+}>;
+/** The processors this platform records payments from. */
+export declare const EXTERNAL_PAYMENT_PROVIDERS: readonly ["stripe"];
+export declare const externalPaymentProviderSchema: z.ZodEnum<["stripe"]>;
+/**
+ * What kind of processor record `externalRef` names.
+ *
+ * Kept explicit because reconciliation compares like with like: a payment intent
+ * and the invoice it paid are two records of one movement of money, and counting
+ * both would double the external total.
+ */
+export declare const EXTERNAL_PAYMENT_KINDS: readonly ["payment_intent", "invoice"];
+export declare const externalPaymentKindSchema: z.ZodEnum<["payment_intent", "invoice"]>;
+/**
+ * A processor payment that funded an Oxy balance.
+ *
+ * This is the reconciliation ANCHOR: one row per charge that landed in the
+ * ledger, carrying both the processor's reference and the ledger entry it
+ * produced. Without it, matching a Stripe charge back to a ledger entry means
+ * parsing an idempotency key, and a parser is not a foreign key.
+ */
+export declare const externalPaymentSchema: z.ZodObject<{
+    id: z.ZodString;
+    accountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    provider: z.ZodEnum<["stripe"]>;
+    externalKind: z.ZodEnum<["payment_intent", "invoice"]>;
+    externalRef: z.ZodString;
+    amount: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    currency: z.ZodString;
+    ledgerEntryId: z.ZodString;
+    occurredAt: z.ZodString;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    accountId: string & z.BRAND<"OxyAccountId">;
+    id: string;
+    occurredAt: string;
+    createdAt: string;
+    amount: string & z.BRAND<"ExactDecimal">;
+    currency: string;
+    provider: "stripe";
+    externalKind: "payment_intent" | "invoice";
+    externalRef: string;
+    ledgerEntryId: string;
+}, {
+    accountId: string;
+    id: string;
+    occurredAt: string;
+    createdAt: string;
+    amount: string;
+    currency: string;
+    provider: "stripe";
+    externalKind: "payment_intent" | "invoice";
+    externalRef: string;
+    ledgerEntryId: string;
+}>;
+/** Lifecycle of one automatic top-up. */
+export declare const AUTO_RECHARGE_STATUSES: readonly ["pending", "succeeded", "failed"];
+export declare const autoRechargeStatusSchema: z.ZodEnum<["pending", "succeeded", "failed"]>;
+/**
+ * One attempt to top an account up automatically.
+ *
+ * Recorded BEFORE the processor is called and keyed on the account, currency and
+ * the window it fired in, so a sweep that runs twice — or two instances of it —
+ * charges a customer's card once. An off-session charge is the one operation on
+ * this surface where a duplicate is not merely a wrong number in a report.
+ */
+export declare const autoRechargeAttemptSchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    accountId: z.ZodBranded<z.ZodString, "OxyAccountId">;
+    currency: z.ZodString;
+    requestedAmount: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    /** The spendable balance that triggered it — why this attempt exists. */
+    balanceAtTrigger: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    status: z.ZodEnum<["pending", "succeeded", "failed"]>;
+    externalRef: z.ZodOptional<z.ZodString>;
+    /** The processor's own decline code. Never a free-form message. */
+    failureCode: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "pending" | "failed" | "succeeded";
+    accountId: string & z.BRAND<"OxyAccountId">;
+    updatedAt: string;
+    id: string;
+    createdAt: string;
+    currency: string;
+    schemaVersion: 1;
+    requestedAmount: string & z.BRAND<"ExactDecimal">;
+    balanceAtTrigger: string & z.BRAND<"ExactDecimal">;
+    failureCode?: string | undefined;
+    externalRef?: string | undefined;
+}, {
+    status: "pending" | "failed" | "succeeded";
+    accountId: string;
+    updatedAt: string;
+    id: string;
+    createdAt: string;
+    currency: string;
+    schemaVersion: 1;
+    requestedAmount: string;
+    balanceAtTrigger: string;
+    failureCode?: string | undefined;
+    externalRef?: string | undefined;
+}>;
+/**
+ * How an Oxy record and a processor record fail to agree.
+ *
+ * A closed set, and every member is a DIFFERENT operational problem:
+ *
+ *  - `missing_in_ledger` — the processor took money Oxy never credited. The
+ *    customer paid and has no balance. This is the one that costs a customer.
+ *  - `missing_in_external` — Oxy credited a balance with no processor charge
+ *    behind it. This is the one that costs Oxy.
+ *  - `amount_mismatch` — both exist and disagree.
+ *  - `account_unresolved` — a processor charge whose customer maps to no Oxy
+ *    account. Money arrived and nobody owns it.
+ *
+ * Collapsing them into a single "discrepancy" count is what makes a
+ * reconciliation report a number nobody acts on.
+ */
+export declare const RECONCILIATION_DISCREPANCY_KINDS: readonly ["missing_in_ledger", "missing_in_external", "amount_mismatch", "account_unresolved"];
+export declare const reconciliationDiscrepancyKindSchema: z.ZodEnum<["missing_in_ledger", "missing_in_external", "amount_mismatch", "account_unresolved"]>;
+export declare const RECONCILIATION_RUN_STATUSES: readonly ["running", "completed", "failed"];
+export declare const reconciliationRunStatusSchema: z.ZodEnum<["running", "completed", "failed"]>;
+export declare const reconciliationDiscrepancySchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    runId: z.ZodString;
+    kind: z.ZodEnum<["missing_in_ledger", "missing_in_external", "amount_mismatch", "account_unresolved"]>;
+    accountId: z.ZodOptional<z.ZodBranded<z.ZodString, "OxyAccountId">>;
+    externalRef: z.ZodOptional<z.ZodString>;
+    ledgerEntryId: z.ZodOptional<z.ZodString>;
+    /** What Oxy recorded. Absent for `missing_in_ledger`. */
+    ledgerAmount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+    /** What the processor recorded. Absent for `missing_in_external`. */
+    externalAmount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+    currency: z.ZodString;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "missing_in_ledger" | "missing_in_external" | "amount_mismatch" | "account_unresolved";
+    id: string;
+    createdAt: string;
+    currency: string;
+    schemaVersion: 1;
+    runId: string;
+    accountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
+    externalRef?: string | undefined;
+    ledgerEntryId?: string | undefined;
+    ledgerAmount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    externalAmount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+}, {
+    kind: "missing_in_ledger" | "missing_in_external" | "amount_mismatch" | "account_unresolved";
+    id: string;
+    createdAt: string;
+    currency: string;
+    schemaVersion: 1;
+    runId: string;
+    accountId?: string | undefined;
+    externalRef?: string | undefined;
+    ledgerEntryId?: string | undefined;
+    ledgerAmount?: string | undefined;
+    externalAmount?: string | undefined;
+}>;
+/**
+ * One reconciliation pass over a window.
+ *
+ * The totals are carried beside the discrepancy list on purpose: two totals that
+ * agree while the lists differ is a real and common state (a charge recorded
+ * against the wrong account), and a report that only published a difference
+ * would call it clean.
+ */
+export declare const reconciliationRunSchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    provider: z.ZodEnum<["stripe"]>;
+    /** Absent for a platform-wide pass. */
+    accountId: z.ZodOptional<z.ZodBranded<z.ZodString, "OxyAccountId">>;
+    currency: z.ZodString;
+    periodStart: z.ZodString;
+    periodEnd: z.ZodString;
+    status: z.ZodEnum<["running", "completed", "failed"]>;
+    ledgerTotal: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    externalTotal: z.ZodBranded<z.ZodString, "ExactDecimal">;
+    discrepancyCount: z.ZodNumber;
+    startedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "completed" | "failed" | "running";
+    id: string;
+    periodEnd: string;
+    currency: string;
+    provider: "stripe";
+    schemaVersion: 1;
+    startedAt: string;
+    periodStart: string;
+    ledgerTotal: string & z.BRAND<"ExactDecimal">;
+    externalTotal: string & z.BRAND<"ExactDecimal">;
+    discrepancyCount: number;
+    accountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
+    completedAt?: string | undefined;
+}, {
+    status: "completed" | "failed" | "running";
+    id: string;
+    periodEnd: string;
+    currency: string;
+    provider: "stripe";
+    schemaVersion: 1;
+    startedAt: string;
+    periodStart: string;
+    ledgerTotal: string;
+    externalTotal: string;
+    discrepancyCount: number;
+    accountId?: string | undefined;
+    completedAt?: string | undefined;
+}>;
+export declare const reconciliationReportSchema: z.ZodObject<{
+    /** See `version.ts`: this shape is served to Console and to Alia. */
+    schemaVersion: z.ZodLiteral<1>;
+    run: z.ZodObject<{
+        /** See `version.ts`: this shape is served to Console and to Alia. */
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        provider: z.ZodEnum<["stripe"]>;
+        /** Absent for a platform-wide pass. */
+        accountId: z.ZodOptional<z.ZodBranded<z.ZodString, "OxyAccountId">>;
+        currency: z.ZodString;
+        periodStart: z.ZodString;
+        periodEnd: z.ZodString;
+        status: z.ZodEnum<["running", "completed", "failed"]>;
+        ledgerTotal: z.ZodBranded<z.ZodString, "ExactDecimal">;
+        externalTotal: z.ZodBranded<z.ZodString, "ExactDecimal">;
+        discrepancyCount: z.ZodNumber;
+        startedAt: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        status: "completed" | "failed" | "running";
+        id: string;
+        periodEnd: string;
+        currency: string;
+        provider: "stripe";
+        schemaVersion: 1;
+        startedAt: string;
+        periodStart: string;
+        ledgerTotal: string & z.BRAND<"ExactDecimal">;
+        externalTotal: string & z.BRAND<"ExactDecimal">;
+        discrepancyCount: number;
+        accountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
+        completedAt?: string | undefined;
+    }, {
+        status: "completed" | "failed" | "running";
+        id: string;
+        periodEnd: string;
+        currency: string;
+        provider: "stripe";
+        schemaVersion: 1;
+        startedAt: string;
+        periodStart: string;
+        ledgerTotal: string;
+        externalTotal: string;
+        discrepancyCount: number;
+        accountId?: string | undefined;
+        completedAt?: string | undefined;
+    }>;
+    discrepancies: z.ZodArray<z.ZodObject<{
+        /** See `version.ts`: this shape is served to Console and to Alia. */
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        runId: z.ZodString;
+        kind: z.ZodEnum<["missing_in_ledger", "missing_in_external", "amount_mismatch", "account_unresolved"]>;
+        accountId: z.ZodOptional<z.ZodBranded<z.ZodString, "OxyAccountId">>;
+        externalRef: z.ZodOptional<z.ZodString>;
+        ledgerEntryId: z.ZodOptional<z.ZodString>;
+        /** What Oxy recorded. Absent for `missing_in_ledger`. */
+        ledgerAmount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+        /** What the processor recorded. Absent for `missing_in_external`. */
+        externalAmount: z.ZodOptional<z.ZodBranded<z.ZodString, "ExactDecimal">>;
+        currency: z.ZodString;
+        createdAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        kind: "missing_in_ledger" | "missing_in_external" | "amount_mismatch" | "account_unresolved";
+        id: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        runId: string;
+        accountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
+        externalRef?: string | undefined;
+        ledgerEntryId?: string | undefined;
+        ledgerAmount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        externalAmount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    }, {
+        kind: "missing_in_ledger" | "missing_in_external" | "amount_mismatch" | "account_unresolved";
+        id: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        runId: string;
+        accountId?: string | undefined;
+        externalRef?: string | undefined;
+        ledgerEntryId?: string | undefined;
+        ledgerAmount?: string | undefined;
+        externalAmount?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
+    run: {
+        status: "completed" | "failed" | "running";
+        id: string;
+        periodEnd: string;
+        currency: string;
+        provider: "stripe";
+        schemaVersion: 1;
+        startedAt: string;
+        periodStart: string;
+        ledgerTotal: string & z.BRAND<"ExactDecimal">;
+        externalTotal: string & z.BRAND<"ExactDecimal">;
+        discrepancyCount: number;
+        accountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
+        completedAt?: string | undefined;
+    };
+    discrepancies: {
+        kind: "missing_in_ledger" | "missing_in_external" | "amount_mismatch" | "account_unresolved";
+        id: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        runId: string;
+        accountId?: (string & z.BRAND<"OxyAccountId">) | undefined;
+        externalRef?: string | undefined;
+        ledgerEntryId?: string | undefined;
+        ledgerAmount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+        externalAmount?: (string & z.BRAND<"ExactDecimal">) | undefined;
+    }[];
+}, {
+    schemaVersion: 1;
+    run: {
+        status: "completed" | "failed" | "running";
+        id: string;
+        periodEnd: string;
+        currency: string;
+        provider: "stripe";
+        schemaVersion: 1;
+        startedAt: string;
+        periodStart: string;
+        ledgerTotal: string;
+        externalTotal: string;
+        discrepancyCount: number;
+        accountId?: string | undefined;
+        completedAt?: string | undefined;
+    };
+    discrepancies: {
+        kind: "missing_in_ledger" | "missing_in_external" | "amount_mismatch" | "account_unresolved";
+        id: string;
+        createdAt: string;
+        currency: string;
+        schemaVersion: 1;
+        runId: string;
+        accountId?: string | undefined;
+        externalRef?: string | undefined;
+        ledgerEntryId?: string | undefined;
+        ledgerAmount?: string | undefined;
+        externalAmount?: string | undefined;
+    }[];
+}>;
+export type BillingMode = z.infer<typeof billingModeSchema>;
+export type BillingProfileStatus = z.infer<typeof billingProfileStatusSchema>;
+export type AutoRecharge = z.infer<typeof autoRechargeSchema>;
+export type BillingProfile = z.infer<typeof billingProfileSchema>;
+export type AccountBillingState = z.infer<typeof accountBillingStateSchema>;
+export type BillingInvoiceStatus = z.infer<typeof billingInvoiceStatusSchema>;
+export type BillingInvoice = z.infer<typeof billingInvoiceSchema>;
+export type ExternalPaymentProvider = z.infer<typeof externalPaymentProviderSchema>;
+export type ExternalPaymentKind = z.infer<typeof externalPaymentKindSchema>;
+export type ExternalPayment = z.infer<typeof externalPaymentSchema>;
+export type AutoRechargeStatus = z.infer<typeof autoRechargeStatusSchema>;
+export type AutoRechargeAttempt = z.infer<typeof autoRechargeAttemptSchema>;
+export type ReconciliationDiscrepancyKind = z.infer<typeof reconciliationDiscrepancyKindSchema>;
+export type ReconciliationRunStatus = z.infer<typeof reconciliationRunStatusSchema>;
+export type ReconciliationDiscrepancy = z.infer<typeof reconciliationDiscrepancySchema>;
+export type ReconciliationRun = z.infer<typeof reconciliationRunSchema>;
+export type ReconciliationReport = z.infer<typeof reconciliationReportSchema>;