@arbidocs/blocks 0.4.147 → 0.4.151

package/dist/connection/billing/AddAddonDialog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AddAddonDialog — confirm adding one add-on block: price today, the next charge, one line; how it is charged is
+ * behind "More info".
+ *
+ *  - ai_usage: +£25 of AI usage a month, charged now at `ai_block_price_pence` (monthly: one
+ *    month; annual: the monthly rate × the months left, covering until the annual renewal).
+ *  - storage: +25 GB, charged now at `storage_block_price_pence`, prorated by days for the rest of
+ *    the period.
+ * The block then renews every period at `ai_block_period_pence` / `storage_block_period_pence`
+ * until the user removes it. The figures shown are taxed for the customer's saved address (GET /addons/quote). The
+ * monthly usage cap limits automatic top-ups only: it never blocks a block added here, even at £0.
+ */
+import type { components } from '@arbidocs/client';
+import { type AddonKind } from './useAddonPurchase';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+export declare function AddAddonDialog({ kind, project, open, onOpenChange, onAdded, }: {
+    kind: AddonKind;
+    project: ProjectResponse;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Called once the block is paid (not when the bank still needs to confirm). */
+    onAdded?: () => void;
+}): import("react").JSX.Element | null;
+export {};

package/dist/connection/billing/BillingCard.d.ts

@@ -0,0 +1,18 @@
+/** The bordered card used by the project billing view (Plan, Usage and plan). */
+import type { ReactNode, Ref } from 'react';
+export declare function BillingCard({ title, testId, action, children, cardRef, }: {
+    title: string;
+    testId: string;
+    action?: ReactNode;
+    children: ReactNode;
+    cardRef?: Ref<HTMLElement>;
+}): import("react").JSX.Element;
+/** A scheduled change, one line, with its Undo. */
+export declare function PendingChange({ children, onUndo, undoLabel, isBusy, testId, undoTestId, }: {
+    children: ReactNode;
+    onUndo?: () => void;
+    undoLabel?: string;
+    isBusy?: boolean;
+    testId: string;
+    undoTestId?: string;
+}): import("react").JSX.Element;

package/dist/connection/billing/BillingProjectEntity.d.ts

@@ -0,0 +1,9 @@
+import { type ProjectRelation } from '@arbidocs/react/ui';
+export interface BillingProjectEntityProps {
+    name: string;
+    subscription?: string;
+    size?: 'sm' | 'base';
+    relation?: ProjectRelation;
+}
+/** The project pill, marked paid only where plans are sold. */
+export declare function BillingProjectEntity({ subscription, ...props }: BillingProjectEntityProps): import("react").JSX.Element;

package/dist/connection/billing/ChangePlanDialog.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ChangePlanDialog — the single source of truth for a project's plan picker.
+ *
+ * Opened from two places that used to each render their own dialog (and drifted
+ * apart in width): the projects list "Upgrade" action and a project's detail
+ * "Change plan" button. Pro projects switch interval or move to Free
+ * (ChangeProPlan); Free or unpaid projects subscribe to Pro (SubscriptionPlans). One wrapper, one
+ * width — so the plan grid can't render cramped in one entry point and spacious
+ * in the other.
+ */
+import type { components } from '@arbidocs/client';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+interface ChangePlanDialogProps {
+    /** The project whose plan is being changed. `null` keeps the dialog closed. */
+    project: ProjectResponse | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ChangePlanDialog({ project, open, onOpenChange }: ChangePlanDialogProps): import("react").JSX.Element;
+export {};

package/dist/connection/billing/ChangeProPlan.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ChangeProPlan — change the plan of a project already on Pro.
+ *
+ * Pro is one licence. Choices: Pro, Free, and the billing interval; a legacy multi-pack plan (no longer
+ * sold) also shows its own count ("Pro ×3", priced from the project) and may only go down to one
+ * licence. One POST /change-plan { interval, packs }:
+ *  - packs is 1, or the subscription's current count (which undoes a scheduled reduction).
+ *  - One licence instead of several applies at period end (`addons.packs_next`), no refund.
+ *  - Monthly ↔ annual switches at period end (`addons.pending_interval`); a plan that renews with
+ *    several packs can't switch interval, so the toggle shows only once one licence is chosen.
+ *  - Sending the current value clears a pending change; on a project set to cancel, it resumes.
+ *  - Free: POST /cancel — Pro and its add-ons stay until the period ends.
+ */
+import type { components } from '@arbidocs/client';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+export declare function ChangeProPlan({ project, onDone, }: {
+    project: ProjectResponse;
+    onDone?: () => void;
+}): import("react").JSX.Element;
+export {};

package/dist/connection/billing/CheckoutTotal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CheckoutTotal — the tax-inclusive total of a plan purchase, shown before Stripe opens:
+ * "Total today £48.00 incl. VAT (£40.00 + £8.00 VAT 20%)". Priced by the backend (Stripe Tax)
+ * for the chosen country, plus a ZIP / postcode where the tax depends on it (e.g. the US).
+ */
+import type { CheckoutQuoteState } from './useCheckoutQuote';
+/** The postcode field (when needed) and the total line. */
+export declare function CheckoutTotal({ state, postalCode, onPostalCodeChange, }: {
+    state: CheckoutQuoteState;
+    postalCode: string;
+    onPostalCodeChange: (value: string) => void;
+}): import("react").JSX.Element;

package/dist/connection/billing/DailyCapEditor.d.ts

@@ -0,0 +1,4 @@
+import { type ProjectResponse } from '@arbidocs/react';
+export declare function DailyCapEditor({ project }: {
+    project: ProjectResponse;
+}): import("react").JSX.Element;

package/dist/connection/billing/InvoicesModal.d.ts

@@ -0,0 +1,6 @@
+export declare function InvoicesModal({ projectExtId, projectName, open, onOpenChange, }: {
+    projectExtId: string;
+    projectName: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}): import("react").JSX.Element;

package/dist/connection/billing/NewProjectFlow.d.ts

@@ -0,0 +1,14 @@
+/**
+ * NewProjectFlow — unified dialog: name → Free or Pro → monthly/annual + promo → checkout.
+ * When Stripe is disabled, just creates a project with a name (no plan selection).
+ * Free creates a usable project immediately. Pro creates a 'pending' project and opens the
+ * embedded Stripe Checkout; a cancelled checkout discards the pending project.
+ * The total for the billing country (incl. tax) is quoted before Stripe opens.
+ */
+interface NewProjectFlowProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    defaultName: string;
+}
+export declare function NewProjectFlow({ open, onOpenChange, defaultName }: NewProjectFlowProps): import("react").JSX.Element;
+export {};

package/dist/connection/billing/PlanChangeLines.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PlanChangeLines — the plan-change panel's fixed lines (pay today / from <date> / current plan
+ * until), from the Stripe preview. Used by the plan picker.
+ */
+import type { components } from '@arbidocs/client';
+type PlanChangePreview = components['schemas']['PlanChangePreview'];
+export declare function PlanChangeLines({ preview, isError, className, }: {
+    preview: PlanChangePreview | undefined;
+    /** The preview failed: say what today's charge is without a figure. */
+    isError?: boolean;
+    className?: string;
+}): import("react").JSX.Element;
+export {};

package/dist/connection/billing/PlanSelector.d.ts

@@ -0,0 +1,50 @@
+/**
+ * PlanSelector — binds the Pro prices to the plan-picker blocks.
+ *
+ * Two plans: Free and Pro (one licence), Pro billed monthly or annually. Used by NewProjectFlow (choose
+ * Free or Pro for a new project) and SubscriptionPlans (upgrade a Free project).
+ * Prices come from Stripe (source of truth): ex VAT, with the UK-inclusive figure under it; the
+ * total for the buyer's country is quoted before checkout. Presentation lives in `@arbidocs/blocks`.
+ */
+import { type PlanChoice, type ProPrices } from './plan-pricing';
+import type { components } from '@arbidocs/client';
+type ProductPrice = components['schemas']['ProductPrice'];
+/**
+ * Free and Pro plan cards. `isOnFree` marks Free as the current (unselectable) plan when
+ * upgrading an existing Free project; omit it for a brand-new project, where both are choices.
+ */
+export declare function PlanChoiceCards({ selected, onSelect, isAnnual, prices, isOnFree, }: {
+    selected: PlanChoice | null;
+    onSelect: (plan: PlanChoice) => void;
+    isAnnual: boolean;
+    prices: ProPrices;
+    isOnFree?: boolean;
+}): import("react").JSX.Element;
+/** "How pricing works" popover; its link opens the AI model list in user settings. */
+export declare function PlanInfoPopover(): import("react").JSX.Element;
+/**
+ * The monthly usage cap at checkout, editable inline, with one short line (the rest is in "How pricing works").
+ * `value` is in pounds; an untouched default is sent as `addon_budget_pence: null`.
+ */
+export declare function CheckoutAddonBudget({ value, onChange, }: {
+    value: string;
+    onChange: (value: string) => void;
+}): import("react").JSX.Element;
+/**
+ * Add-on blocks bought with Pro at checkout: "+£25 of AI usage" and "+25 GB storage" steppers (0..100 each), priced
+ * per block on the chosen interval. They are on the first invoice and renew until reduced ("How pricing works").
+ */
+export declare function CheckoutAddonBlocks({ aiBlocks, storageBlocks, onAiBlocksChange, onStorageBlocksChange, price, }: {
+    aiBlocks: number;
+    storageBlocks: number;
+    onAiBlocksChange: (value: number) => void;
+    onStorageBlocksChange: (value: number) => void;
+    /** The plan price on the chosen interval; its `addon_prices` price each block. */
+    price?: ProductPrice;
+}): import("react").JSX.Element;
+/** The billing country, chosen before checkout so Stripe prices it with the right tax. */
+export declare function CheckoutCountrySelect({ value, onChange, }: {
+    value: string;
+    onChange: (code: string) => void;
+}): import("react").JSX.Element;
+export {};

package/dist/connection/billing/ProjectBilling.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ProjectBilling — the owner's billing view of one project: Plan / Usage and plan.
+ *
+ *  - Plan card: what you have (plan, renewal date, price), any scheduled change with Undo, and
+ *    billing problems (Free / Dev: also the AI usage and storage meters). "Change plan" is its one
+ *    action.
+ *  - Usage and plan card (Pro only, `ProjectUsageCard`): a usage meter per resource with + / −
+ *    beside it, and the monthly usage cap, which limits automatic top-ups only (£100 by default for
+ *    new projects; £0 = no automatic top-ups; "No limit" allowed).
+ *
+ * Reductions and plan downgrades take effect at the end of the period; no refunds.
+ */
+import type { components } from '@arbidocs/client';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+export declare function ProjectPlanCard({ project, onChangePlan, }: {
+    project: ProjectResponse;
+    /** Opens the plan picker (upgrade from Free, or change plan on Pro). */
+    onChangePlan?: () => void;
+}): import("react").JSX.Element;
+export declare function ProjectBilling({ project, onChangePlan, }: {
+    project: ProjectResponse;
+    onChangePlan?: () => void;
+}): import("react").JSX.Element;
+export {};

package/dist/connection/billing/ProjectDetail.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ProjectDetail
+ *
+ * Content of an opened per-project tab. Only your OWN projects are openable
+ * (the table gates this), so this is purely the deep detail: the daily-cap
+ * setter for others on the project, plus the usage breakdown. The high-level
+ * summary (plan, AI usage, storage, collaborators) lives in the projects list;
+ * renaming the project is done here, from the pencil beside its name.
+ */
+import { type ReactNode } from 'react';
+export interface ProjectDetailProps {
+    projectExtId: string;
+    /** The project's storage (by workspace and kind, largest items, recently deleted), from the host. */
+    storage?: ReactNode;
+}
+export declare function ProjectDetail({ projectExtId, storage }: ProjectDetailProps): import("react").JSX.Element;

package/dist/connection/billing/ProjectUsageCard.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ProjectUsageCard — a Pro project's "Usage and plan" card: one usage meter per resource (AI usage this month,
+ * storage) and the monthly usage cap. Short labels and one-line facts only; how top-ups, proration, the cap and
+ * reductions work is behind the card's "More info" link.
+ *
+ * Each meter shows used vs the allowance now, marking the plan's part and shading the top-ups, hatches how much more
+ * automatic top-ups may add before the usage cap stops them ("No limit" / £0 states), says what renews from the next
+ * period when that differs (with Undo), and has + / − beside it with the price of one step:
+ *  - "+" opens the add confirm (charged now: AI usage the full block, storage prorated for the rest of the period);
+ *    the usage cap never blocks it.
+ *  - "−" opens a one-click confirm that removes one block from the next renewal; this period's allowance stays.
+ * The usage cap limits automatic top-ups only (default £100; £0 = no automatic top-ups; or no limit).
+ */
+import type { components } from '@arbidocs/client';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+type ProjectAddons = components['schemas']['ProjectAddons'];
+export declare function ProjectUsageCard({ project, addons, }: {
+    project: ProjectResponse;
+    addons: ProjectAddons;
+}): import("react").JSX.Element;
+export {};

package/dist/connection/billing/ProjectUsageContent.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ProjectUsageContent — inline AI usage breakdown for a project.
+ *
+ * SVG line chart with composite color-coded lines.
+ * Toggle between breakdowns: User (default), Workspace, Model Tier.
+ * Resolves usr-xxx / wrk-xxx IDs to real names via workspace data.
+ * Data from LiteLLM via /v1/user/projects/{id}/usage.
+ *
+ * Rendered inline in the project card expander (no dialog).
+ */
+interface ProjectUsageContentProps {
+    projectExtId: string;
+    projectName: string;
+    /** Monthly AI usage quota in £ (quotas.ai_usage.limit) — enables the % indicator */
+    aiUsageLimit?: number;
+}
+export declare function ProjectUsageContent({ projectExtId, projectName, aiUsageLimit, }: ProjectUsageContentProps): import("react").JSX.Element;
+export {};

package/dist/connection/billing/ProjectsTable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ProjectsTable
+ *
+ * Compact list of the user's own projects. Each project is a single clickable
+ * line that opens the project's usage detail in its own tab; rename / delete /
+ * invoices / upgrade live as hover actions on the right. Plan + quota info only
+ * appears when Stripe billing is enabled (no plan concept otherwise).
+ *
+ * Projects owned by someone else aren't listed here — they're surfaced on the
+ * workspace cards the user collaborates on.
+ */
+/** The user's own projects: plan, usage, upgrade and invoices; a row opens the project. */
+export declare function ProjectsTable(): import("react").JSX.Element;

package/dist/connection/billing/ReduceAddonDialog.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ReduceAddonDialog — confirm removing one AI usage / storage block (−£25 / −25 GB) from the next period.
+ *
+ * One click on "−" opens it; one click confirms. The reduction applies from the next renewal (`period_end`): this
+ * period's allowance stays until then and nothing is refunded, so an automatic top-up can be turned back down to
+ * cover only the current period. Each confirm removes one more block from what renews (today's blocks go first;
+ * legacy blocks keep their old size). Storage can't renew below what the files need (`storage_blocks_min`).
+ */
+import type { components } from '@arbidocs/client';
+import { type AddonKind } from './useAddonPurchase';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+export declare function ReduceAddonDialog({ kind, project, open, onOpenChange, }: {
+    kind: AddonKind;
+    project: ProjectResponse;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}): import("react").JSX.Element | null;
+export {};

package/dist/connection/billing/ReferralReward.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ReferralReward — binds the user's referral reward to the reward blocks.
+ *
+ * The reward is a single GLOBAL per-user Stripe account balance (mirrored read-only
+ * into `settings.extra_discount`) that auto-applies to the user's NEXT invoice. Surfaced as:
+ *   - `ReferralRewardBadge`   — standing indicator in the Projects tab header.
+ *   - `ReferralRewardSummary` — "subtotal / −reward / you pay now" where the charge is known
+ *                               exactly (new-project first invoice == the shown total).
+ *   - `ReferralRewardNote`    — a one-line note where the exact charge is a proration we
+ *                               can't compute client-side (switching an existing Pro plan).
+ *
+ * Logic + the `useReferralReward` hook live in `./referral-reward`; the presentation in
+ * `@arbidocs/blocks`.
+ */
+/** Standing pill for the Projects tab header — the global available reward. */
+export declare function ReferralRewardBadge(): import("react").JSX.Element | null;
+/**
+ * Available referral reward shown alongside a new-project purchase. When the exact charge is
+ * known (`totalCents` + `currency`), we do the math and show subtotal / −reward / you pay now;
+ * otherwise we fall back to a one-line note. Renders nothing when there's no reward.
+ */
+export declare function ReferralRewardSummary({ totalCents, currency, }: {
+    /** The known charge for this purchase, in minor units (e.g. pennies). */
+    totalCents?: number;
+    /** Currency of the charge — must match the reward's currency to apply. */
+    currency?: string;
+}): import("react").JSX.Element | null;
+/**
+ * One-line note for charges whose exact amount is a proration we don't compute client-side
+ * (switching an existing Pro subscription). Stripe applies the reward at charge time.
+ */
+export declare function ReferralRewardNote(): import("react").JSX.Element | null;

package/dist/connection/billing/SharedProjects.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Projects shared with you — the collaborator's view of other people's
+ * projects. You draw on their budget under a personal daily cap, and that
+ * allowance is the ONLY number that is yours to see: no plan, no billing,
+ * no project totals (the backend doesn't share them with non-owners, and
+ * pretending otherwise is what made this surface cryptic). Renders on every
+ * deployment — quotas are not a billing feature.
+ *
+ * `used_gbp` is the user's deployment-wide spend today; pairing it with
+ * each project's `daily_cap_per_user` is the sanctioned reading (see
+ * useUserUsageToday of @arbidocs/react).
+ */
+export declare function SharedProjects(): import("react").JSX.Element | null;

package/dist/connection/billing/StripeCheckoutModal.d.ts

@@ -0,0 +1,32 @@
+/**
+ * StripeCheckoutModal Component
+ *
+ * Modal with embedded Stripe checkout for a Pro subscription.
+ * Uses Stripe Elements for secure payment processing.
+ * Checkout is scoped to a specific project.
+ */
+import { type TaxQuote } from './tax-quote';
+interface StripeCheckoutModalProps {
+    projectExtId: string;
+    /** Pro billing interval: monthly or annual. */
+    interval: 'month' | 'year';
+    /** Monthly usage cap chosen at checkout (pence); null/omitted keeps the default. */
+    addonBudgetPence?: number | null;
+    /** Add-on blocks bought with the plan (+£25 of AI usage a month / +25 GB each): on the first invoice. */
+    aiBlocks?: number;
+    storageBlocks?: number;
+    promoCode?: string;
+    /** ISO-2 billing country picked before checkout; prefills the Stripe customer's address. */
+    billingCountry?: string;
+    /** ZIP / postcode, where the tax depends on it (e.g. the US). */
+    postalCode?: string;
+    /** The total quoted before checkout, repeated above Stripe's summary. */
+    quote?: TaxQuote;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Called when Stripe reports the payment completed (before the dialog closes),
+     *  so callers can distinguish a successful checkout from a cancel/close. */
+    onCompleted?: () => void;
+}
+export declare function StripeCheckoutModal({ projectExtId, interval, addonBudgetPence, aiBlocks, storageBlocks, promoCode, billingCountry, postalCode, quote, open, onOpenChange, onCompleted, }: StripeCheckoutModalProps): import("react").JSX.Element;
+export {};

package/dist/connection/billing/SubscriptionPlans.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SubscriptionPlans — upgrade a Free project to Pro (monthly or annual).
+ * Rendered inside the plan dialog. The total for the billing country (incl. tax) is quoted here,
+ * before Stripe Checkout opens.
+ */
+interface SubscriptionPlansProps {
+    projectExtId: string;
+    /** Declining the upgrade. When set, an explicit opt-out sits under Subscribe —
+     * a dialog that opens on you (the welcome modal) needs a way out that isn't the
+     * corner ✕. Omitted where the plans render inline (settings), which has no
+     * dialog to close. */
+    onDismiss?: () => void;
+}
+export declare function SubscriptionPlans({ projectExtId, onDismiss }: SubscriptionPlansProps): import("react").JSX.Element | null;
+export {};

package/dist/connection/billing/SubscriptionStatus.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SubscriptionStatus: binds a project's quotas and billing state to the blocks status view
+ * (AI usage reset date, canceling notice, quota meters).
+ */
+import type { components } from '@arbidocs/client';
+interface SubscriptionStatusProps {
+    project: components['schemas']['ProjectResponse'];
+}
+export declare function SubscriptionStatus({ project }: SubscriptionStatusProps): import("react").JSX.Element;
+export {};

package/dist/connection/billing/addon-pricing.d.ts

@@ -0,0 +1,97 @@
+/** Add-on block price helpers (VAT-inclusive pence from `project.addons`). */
+import type { components } from '@arbidocs/client';
+import type { AddonKind } from './useAddonPurchase';
+type ProjectAddons = components['schemas']['ProjectAddons'];
+/** "3 Nov 2026". */
+export declare function formatPeriodEnd(unix: number | null | undefined): string | null;
+/** What one more block of this kind costs right now, incl. UK VAT. */
+export declare function addonPricePence(kind: AddonKind, addons: ProjectAddons): number;
+/** The same price ex VAT. */
+export declare function addonPriceExVatPence(kind: AddonKind, addons: ProjectAddons): number;
+/**
+ * The PUT /addons/settings body (the monthly usage cap and the automatic add-on trigger) from the current add-on
+ * state with the given changes applied.
+ */
+export declare function addonSettingsBody(addons: ProjectAddons, change?: Partial<{
+    spend_cap_pence: number | null;
+    auto_topup_threshold_gbp: number;
+}>): {
+    spend_cap_pence: number | null;
+    auto_topup_threshold_gbp: number;
+};
+/**
+ * Of `count` blocks of a kind, how many are on an earlier catalogue's price (legacy, at their old size: £10 of AI
+ * usage or 10 GB) and how many on today's. A reduction removes today's blocks first, so the legacy ones are the
+ * last kept.
+ */
+export declare function splitBlocks(kind: AddonKind, count: number, addons: ProjectAddons): {
+    legacy: number;
+    current: number;
+};
+/**
+ * "2 × £25 of AI usage", "1 × £10 + 1 × £25 of AI usage", "1 × 10 GB + 2 × 25 GB": `count` blocks of a kind, the
+ * legacy ones (kept last on a reduction) at their old size.
+ */
+export declare function blocksLabel(kind: AddonKind, count: number, addons: ProjectAddons): string;
+/**
+ * Bounds for "Reduce from next period": keep `min`..`current` blocks. `next` is what renews
+ * now (a pending reduction, or the current count). Storage can't go below what usage needs.
+ */
+export declare function reduceBounds(kind: AddonKind, addons: ProjectAddons): {
+    min: number;
+    current: number;
+    next: number;
+};
+/** What one add-on renews at: "£25/month + VAT" or "£225/year + VAT". */
+export declare function blockRenewalShort(kind: AddonKind, addons: ProjectAddons, isAnnual: boolean): string;
+/** The extra line annual plans show beside an AI usage add-on or upgrade price. */
+export declare const ANNUAL_PREMIUM_AI_NOTE = "No markup on Premium AI on annual plans";
+/** The confirm dialog's figures: charged now (incl. / ex VAT), what it covers until, then what renews. */
+export declare function addonCharge(kind: AddonKind, addons: ProjectAddons, isAnnual: boolean, periodEnd: number | null | undefined): {
+    now: string;
+    nowExVat: string;
+    nowVat: string;
+    until: string | null;
+    then: string;
+};
+/** Why automatic top-ups stopped (one line; the price of a step is on the Add button). */
+export declare const CAP_REACHED_MESSAGE = "Usage cap reached: no more automatic top-ups this month.";
+/** The £0 usage cap: no automatic top-ups (adding by hand still works). */
+export declare const ZERO_BUDGET_MESSAGE = "Automatic top-ups are off (\u00A30 usage cap).";
+/** The usage cap's heading wherever it is edited or shown. */
+export declare const USAGE_CAP_LABEL = "Usage cap";
+/** What the usage cap means (in "More info"): £0 and "No limit" explained. */
+export declare const USAGE_CAP_HELP: string;
+/** A £0 cap turns automatic top-ups off (manual adds still work). */
+export declare function isAddonBudgetZero(addons: Pick<ProjectAddons, 'spend_cap_pence'>): boolean;
+/**
+ * How much more of a resource automatic top-ups may add this month before the usage cap stops them, in the
+ * resource's unit (£ of AI usage / GB): the whole blocks the cap left pays for at today's ex-VAT price. `null` =
+ * no limit; 0 with a £0 cap or when not even one block fits.
+ */
+export declare function autoRoom(kind: AddonKind, addons: ProjectAddons): number | null;
+/** The size of the block a one-step reduction removes from what renews (today's blocks go first). */
+export declare function nextRemovedBlockSize(kind: AddonKind, addons: ProjectAddons): number;
+/**
+ * Pounds typed into a usage cap field → pence. '' → the default (null); invalid → undefined.
+ * Equal to the default is also sent as null ("keep the default").
+ */
+export declare function parseBudgetPounds(value: string): number | null | undefined;
+/** Toast after saving the usage cap. */
+export declare function budgetSavedMessage(capPence: number | null): string;
+/** "£25 of AI usage" / "25 GB". */
+export declare function stepLabel(kind: AddonKind, size: number): string;
+/** The PUT /addons/next-period body that renews `keep` blocks of `kind` (the other kind unchanged). */
+export declare function nextPeriodBody(kind: AddonKind, keep: number): {
+    ai_blocks: number;
+    storage_blocks: null;
+} | {
+    ai_blocks: null;
+    storage_blocks: number;
+};
+/**
+ * The "+" step's price line, ex VAT: "£25/month · today £25" (annual: "£18.75/month · today £150");
+ * storage, charged for the rest of the period: "£25/month · prorated today £8.33".
+ */
+export declare function addStepCaption(kind: AddonKind, addons: ProjectAddons): string;
+export {};

package/dist/connection/billing/api-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The `detail` of a refused billing call: the response body's `detail` (a string, or the
+ * `{code, message}` of a payment refusal), whether the error is an SDK `ArbiApiError` (body in
+ * `apiError`) or the body itself.
+ */
+export declare function apiErrorDetail(error: unknown): unknown;

package/dist/connection/billing/billing-country.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Billing country chosen before checkout (ISO 3166-1 alpha-2). Sent to the checkout API as
+ * `billing_country` so the backend can prefill the Stripe customer's address, and Stripe Tax shows
+ * the tax-inclusive total from the first frame.
+ */
+export declare const DEFAULT_BILLING_COUNTRY = "GB";
+export declare const BILLING_COUNTRY_CODES: readonly string[];
+/** The select's options: the United Kingdom first, then every other country by name. */
+export declare function billingCountryOptions(): {
+    code: string;
+    name: string;
+}[];
+/** The region of the browser's first locale that names a country ("en-US" → "US"), else GB. */
+export declare function defaultBillingCountry(languages?: readonly string[]): string;

package/dist/connection/billing/billing-focus.d.ts

@@ -0,0 +1,11 @@
+export interface ProjectBillingFocus {
+    projectExtId: string;
+    /** Open the project's upgrade dialog. */
+    openUpgrade: boolean;
+    /** Scroll to and focus this card of the project's billing. */
+    section?: 'spend-cap';
+}
+/** Ask the billing UI to focus a project (or clear the request with `null`). */
+export declare function requestProjectBillingFocus(next: ProjectBillingFocus | null): void;
+/** The pending billing focus request, if any. */
+export declare function useProjectBillingFocus(): ProjectBillingFocus | null;

package/dist/connection/billing/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The billing kit: a host's projects (plan, usage, add-ons, invoices), the plan picker and checkout,
+ * new projects, and the projects shared with the user. Stripe stays the host's
+ * (`BillingSupportProvider`); without it projects show their limits and usage only.
+ */
+export { BillingSupportProvider, useBillingSupport, type BillingSupport, type BillingCheckoutSupport, } from './support';
+export { requestProjectBillingFocus, useProjectBillingFocus, type ProjectBillingFocus, } from './billing-focus';
+export { ProjectsTable } from './ProjectsTable';
+export { SharedProjects } from './SharedProjects';
+export { ProjectDetail, type ProjectDetailProps } from './ProjectDetail';
+export { NewProjectFlow } from './NewProjectFlow';
+export { ChangePlanDialog } from './ChangePlanDialog';
+export { AddAddonDialog } from './AddAddonDialog';
+export { InvoicesModal } from './InvoicesModal';
+export { BillingProjectEntity, type BillingProjectEntityProps } from './BillingProjectEntity';
+export { useOpenBillingPortal } from './useOpenBillingPortal';
+export { useAutoRefreshPendingProjects } from './useAutoRefreshPendingProjects';
+export { formatMoney, useRewardBalance, type RewardBalance } from './reward-balance';
+export { REFERRAL_OFFER, useReferralReward } from './referral-reward';
+export { isProProject, planBadgeView, planName } from './plan-badge';
+export { aiUsageResetTimestamp, formatResetDate, getQuotaItems } from './quota-items';
+export { CAP_REACHED_MESSAGE, ZERO_BUDGET_MESSAGE, isAddonBudgetZero } from './addon-pricing';

package/dist/connection/billing/plan-badge.d.ts

@@ -0,0 +1,15 @@
+import type { PlanBadgeProps } from '../../settings';
+import type { components } from '@arbidocs/client';
+type ProjectBillingFields = Pick<components['schemas']['ProjectResponse'], 'subscription' | 'plan_interval'> & Partial<Pick<components['schemas']['ProjectResponse'], 'packs' | 'addons'>>;
+/** A project is on Pro when it has a billing interval (null = Free or checkout pending). */
+export declare function isProProject(project: Pick<ProjectBillingFields, 'plan_interval'>): boolean;
+/** "Pro", or a legacy multi-pack plan's name ("Pro ×N") — the API's name when it sends one (owner view). */
+export declare function proTierName(project: ProjectBillingFields): string;
+/** "Free", "Pro monthly", "Pro annual", "Pro ×3 monthly" (legacy) or "Dev" — the full plan name. */
+export declare function planName(project: ProjectBillingFields): string;
+/**
+ * Maps a project's billing state to the `PlanBadge` block's label + tone.
+ * Pro reads as accent, Free/dev as neutral, payment trouble or cancelling as pending.
+ */
+export declare function planBadgeView(project: ProjectBillingFields): Pick<PlanBadgeProps, 'label' | 'tone'>;
+export {};

package/dist/connection/billing/plan-change-outcome.d.ts

@@ -0,0 +1,15 @@
+/**
+ * What change-plan did, from `ProjectResponse.plan_change`, as one notification:
+ *  - upgraded        → "Upgraded to Pro · £48.00 charged"
+ *  - scheduled       → "Scheduled for 16 Nov 2026"
+ *  - requires_action → "Confirm with your bank. Nothing is charged until you do." + Confirm
+ *  - unchanged / no outcome → the caller's own message.
+ */
+import type { components } from '@arbidocs/client';
+type ProjectResponse = components['schemas']['ProjectResponse'];
+export declare const BANK_CONFIRM_PLAN_CHANGE = "Confirm with your bank. Nothing is charged until you do.";
+/** Returns the outcome's result, so callers can tell a finished upgrade from one still waiting. */
+export declare function notifyPlanChange(data: ProjectResponse | undefined, fallback: string, 
+/** The plan an upgrade went to, when the caller knows it. */
+planName?: string): 'upgraded' | 'scheduled' | 'unchanged' | 'requires_action' | null;
+export {};