@aglyn/aglyn 1.0.0-beta.270 → 1.0.0-beta.271

package/src/lib/app-utils/append-only-history.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * APPEND-ONLY HISTORY (AGL-3959).
+ *
+ * Work that bills — Site Care minutes and extra time, and the flat-quoted
+ * project invoice after it (AGL-3970) — keeps one dated row per thing that
+ * happened: a minute entry, a timer start, an approval, a charge, an email,
+ * a correction. Nothing is overwritten. A fix is a new row that says what it
+ * was before, what it is now, who changed it and why, so the record a person
+ * can be shown is the whole record.
+ *
+ * Each row carries two tellings of the same fact: `summary`, written for the
+ * owner in plain words (it is what their statement lists), and the
+ * structured `before` / `after` / `stripe` a staff member or the
+ * reconciliation reads. This module is the row's shape and its rules; the
+ * write — always a `create`, in the same batch as the change it records — is
+ * `@aglyn/tenant-data-admin/server/append-only-history-write`.
+ */
+/** The longest reason or summary a row keeps. */
+export declare const HISTORY_TEXT_MAX = 500;
+/** The Stripe object a row's money movement names. */
+export interface HistoryStripeRef {
+    /** `invoiceitem`, `credit_note`, `refund`, `invoice`. */
+    object: string;
+    id: string;
+    /** Whole cents the object moved, when it moved money. */
+    amountCents?: number;
+}
+/** One row. */
+export interface AppendOnlyHistoryRow {
+    /** When it happened, epoch ms. */
+    atMs: number;
+    /** Who did it; null when nobody did (a scheduled check). */
+    byUid: string | null;
+    byEmail: string | null;
+    /** What kind of thing happened, `noun.verb`: `minutes.corrected`. */
+    kind: string;
+    /** What happened, in plain words an owner can read. */
+    summary: string;
+    /** Why; required on every correction. */
+    reason: string | null;
+    before: Readonly<Record<string, unknown>> | null;
+    after: Readonly<Record<string, unknown>> | null;
+    stripe: HistoryStripeRef | null;
+    /** The record the row belongs to, when the history is shared by many. */
+    subjectId: string | null;
+}
+export interface HistoryRowInput {
+    atMs: number;
+    by: {
+        uid: string | null;
+        email: string | null;
+    };
+    kind: string;
+    summary: string;
+    reason?: string | null;
+    before?: Readonly<Record<string, unknown>> | null;
+    after?: Readonly<Record<string, unknown>> | null;
+    stripe?: HistoryStripeRef | null;
+    subjectId?: string | null;
+}
+/** A trimmed, bounded reason, or null when blank. */
+export declare function cleanHistoryReason(reason: unknown): string | null;
+/**
+ * The reason a correction must carry, or an error to show. Every change to
+ * something already recorded goes through this, so "why" is never optional
+ * where it matters.
+ */
+export declare function requireHistoryReason(reason: unknown): {
+    ok: true;
+    reason: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** A row from its parts, every field present so a reader never guesses. */
+export declare function historyRow(input: HistoryRowInput): AppendOnlyHistoryRow;
+/** Rows oldest first, ties kept in the order they were read. */
+export declare function sortHistoryRows<Row extends Pick<AppendOnlyHistoryRow, 'atMs'>>(rows: readonly Row[]): Row[];

package/src/lib/app-utils/append-only-history.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * APPEND-ONLY HISTORY (AGL-3959).
+ *
+ * Work that bills — Site Care minutes and extra time, and the flat-quoted
+ * project invoice after it (AGL-3970) — keeps one dated row per thing that
+ * happened: a minute entry, a timer start, an approval, a charge, an email,
+ * a correction. Nothing is overwritten. A fix is a new row that says what it
+ * was before, what it is now, who changed it and why, so the record a person
+ * can be shown is the whole record.
+ *
+ * Each row carries two tellings of the same fact: `summary`, written for the
+ * owner in plain words (it is what their statement lists), and the
+ * structured `before` / `after` / `stripe` a staff member or the
+ * reconciliation reads. This module is the row's shape and its rules; the
+ * write — always a `create`, in the same batch as the change it records — is
+ * `@aglyn/tenant-data-admin/server/append-only-history-write`.
+ */ /** The longest reason or summary a row keeps. */ export const HISTORY_TEXT_MAX = 500;
+/** A trimmed, bounded reason, or null when blank. */ export function cleanHistoryReason(reason) {
+    const text = typeof reason === 'string' ? reason.trim().slice(0, HISTORY_TEXT_MAX) : '';
+    return text ? text : null;
+}
+/**
+ * The reason a correction must carry, or an error to show. Every change to
+ * something already recorded goes through this, so "why" is never optional
+ * where it matters.
+ */ export function requireHistoryReason(reason) {
+    const cleaned = cleanHistoryReason(reason);
+    return cleaned ? {
+        ok: true,
+        reason: cleaned
+    } : {
+        ok: false,
+        error: 'Say why — a reason is required.'
+    };
+}
+/** A row from its parts, every field present so a reader never guesses. */ export function historyRow(input) {
+    var _input_by_uid, _input_by_email, _input_summary, _input_reason, _input_before, _input_after, _input_stripe, _input_subjectId;
+    return {
+        atMs: Math.floor(input.atMs),
+        byUid: (_input_by_uid = input.by.uid) != null ? _input_by_uid : null,
+        byEmail: (_input_by_email = input.by.email) != null ? _input_by_email : null,
+        kind: input.kind,
+        summary: String((_input_summary = input.summary) != null ? _input_summary : '').trim().slice(0, HISTORY_TEXT_MAX),
+        reason: cleanHistoryReason((_input_reason = input.reason) != null ? _input_reason : null),
+        before: (_input_before = input.before) != null ? _input_before : null,
+        after: (_input_after = input.after) != null ? _input_after : null,
+        stripe: (_input_stripe = input.stripe) != null ? _input_stripe : null,
+        subjectId: (_input_subjectId = input.subjectId) != null ? _input_subjectId : null
+    };
+}
+/** Rows oldest first, ties kept in the order they were read. */ export function sortHistoryRows(rows) {
+    return rows.map((row, index)=>({
+            row,
+            index
+        })).sort((a, b)=>a.row.atMs - b.row.atMs || a.index - b.index).map(({ row })=>row);
+}
+
+//# sourceMappingURL=append-only-history.js.map

package/src/lib/app-utils/append-only-history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/append-only-history.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * APPEND-ONLY HISTORY (AGL-3959).\n *\n * Work that bills — Site Care minutes and extra time, and the flat-quoted\n * project invoice after it (AGL-3970) — keeps one dated row per thing that\n * happened: a minute entry, a timer start, an approval, a charge, an email,\n * a correction. Nothing is overwritten. A fix is a new row that says what it\n * was before, what it is now, who changed it and why, so the record a person\n * can be shown is the whole record.\n *\n * Each row carries two tellings of the same fact: `summary`, written for the\n * owner in plain words (it is what their statement lists), and the\n * structured `before` / `after` / `stripe` a staff member or the\n * reconciliation reads. This module is the row's shape and its rules; the\n * write — always a `create`, in the same batch as the change it records — is\n * `@aglyn/tenant-data-admin/server/append-only-history-write`.\n */\n\n/** The longest reason or summary a row keeps. */\nexport const HISTORY_TEXT_MAX = 500\n\n/** The Stripe object a row's money movement names. */\nexport interface HistoryStripeRef {\n  /** `invoiceitem`, `credit_note`, `refund`, `invoice`. */\n  object: string\n  id: string\n  /** Whole cents the object moved, when it moved money. */\n  amountCents?: number\n}\n\n/** One row. */\nexport interface AppendOnlyHistoryRow {\n  /** When it happened, epoch ms. */\n  atMs: number\n  /** Who did it; null when nobody did (a scheduled check). */\n  byUid: string | null\n  byEmail: string | null\n  /** What kind of thing happened, `noun.verb`: `minutes.corrected`. */\n  kind: string\n  /** What happened, in plain words an owner can read. */\n  summary: string\n  /** Why; required on every correction. */\n  reason: string | null\n  before: Readonly<Record<string, unknown>> | null\n  after: Readonly<Record<string, unknown>> | null\n  stripe: HistoryStripeRef | null\n  /** The record the row belongs to, when the history is shared by many. */\n  subjectId: string | null\n}\n\nexport interface HistoryRowInput {\n  atMs: number\n  by: { uid: string | null; email: string | null }\n  kind: string\n  summary: string\n  reason?: string | null\n  before?: Readonly<Record<string, unknown>> | null\n  after?: Readonly<Record<string, unknown>> | null\n  stripe?: HistoryStripeRef | null\n  subjectId?: string | null\n}\n\n/** A trimmed, bounded reason, or null when blank. */\nexport function cleanHistoryReason(reason: unknown): string | null {\n  const text = typeof reason === 'string' ? reason.trim().slice(0, HISTORY_TEXT_MAX) : ''\n  return text ? text : null\n}\n\n/**\n * The reason a correction must carry, or an error to show. Every change to\n * something already recorded goes through this, so \"why\" is never optional\n * where it matters.\n */\nexport function requireHistoryReason(\n  reason: unknown,\n): { ok: true; reason: string } | { ok: false; error: string } {\n  const cleaned = cleanHistoryReason(reason)\n  return cleaned ? { ok: true, reason: cleaned } : { ok: false, error: 'Say why — a reason is required.' }\n}\n\n/** A row from its parts, every field present so a reader never guesses. */\nexport function historyRow(input: HistoryRowInput): AppendOnlyHistoryRow {\n  return {\n    atMs: Math.floor(input.atMs),\n    byUid: input.by.uid ?? null,\n    byEmail: input.by.email ?? null,\n    kind: input.kind,\n    summary: String(input.summary ?? '').trim().slice(0, HISTORY_TEXT_MAX),\n    reason: cleanHistoryReason(input.reason ?? null),\n    before: input.before ?? null,\n    after: input.after ?? null,\n    stripe: input.stripe ?? null,\n    subjectId: input.subjectId ?? null,\n  }\n}\n\n/** Rows oldest first, ties kept in the order they were read. */\nexport function sortHistoryRows<Row extends Pick<AppendOnlyHistoryRow, 'atMs'>>(\n  rows: readonly Row[],\n): Row[] {\n  return rows\n    .map((row, index) => ({ row, index }))\n    .sort((a, b) => a.row.atMs - b.row.atMs || a.index - b.index)\n    .map(({ row }) => row)\n}\n"],"names":["HISTORY_TEXT_MAX","cleanHistoryReason","reason","text","trim","slice","requireHistoryReason","cleaned","ok","error","historyRow","input","atMs","Math","floor","byUid","by","uid","byEmail","email","kind","summary","String","before","after","stripe","subjectId","sortHistoryRows","rows","map","row","index","sort","a","b"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;CAgBC,GAED,+CAA+C,GAC/C,OAAO,MAAMA,mBAAmB,IAAG;AA2CnC,mDAAmD,GACnD,OAAO,SAASC,mBAAmBC,MAAe;IAChD,MAAMC,OAAO,OAAOD,WAAW,WAAWA,OAAOE,IAAI,GAAGC,KAAK,CAAC,GAAGL,oBAAoB;IACrF,OAAOG,OAAOA,OAAO;AACvB;AAEA;;;;CAIC,GACD,OAAO,SAASG,qBACdJ,MAAe;IAEf,MAAMK,UAAUN,mBAAmBC;IACnC,OAAOK,UAAU;QAAEC,IAAI;QAAMN,QAAQK;IAAQ,IAAI;QAAEC,IAAI;QAAOC,OAAO;IAAkC;AACzG;AAEA,yEAAyE,GACzE,OAAO,SAASC,WAAWC,KAAsB;QAGtCA,eACEA,iBAEOA,gBACWA,eACnBA,eACDA,cACCA,eACGA;IAVb,OAAO;QACLC,MAAMC,KAAKC,KAAK,CAACH,MAAMC,IAAI;QAC3BG,KAAK,GAAEJ,gBAAAA,MAAMK,EAAE,CAACC,GAAG,YAAZN,gBAAgB;QACvBO,OAAO,GAAEP,kBAAAA,MAAMK,EAAE,CAACG,KAAK,YAAdR,kBAAkB;QAC3BS,MAAMT,MAAMS,IAAI;QAChBC,SAASC,QAAOX,iBAAAA,MAAMU,OAAO,YAAbV,iBAAiB,IAAIP,IAAI,GAAGC,KAAK,CAAC,GAAGL;QACrDE,QAAQD,oBAAmBU,gBAAAA,MAAMT,MAAM,YAAZS,gBAAgB;QAC3CY,MAAM,GAAEZ,gBAAAA,MAAMY,MAAM,YAAZZ,gBAAgB;QACxBa,KAAK,GAAEb,eAAAA,MAAMa,KAAK,YAAXb,eAAe;QACtBc,MAAM,GAAEd,gBAAAA,MAAMc,MAAM,YAAZd,gBAAgB;QACxBe,SAAS,GAAEf,mBAAAA,MAAMe,SAAS,YAAff,mBAAmB;IAChC;AACF;AAEA,8DAA8D,GAC9D,OAAO,SAASgB,gBACdC,IAAoB;IAEpB,OAAOA,KACJC,GAAG,CAAC,CAACC,KAAKC,QAAW,CAAA;YAAED;YAAKC;QAAM,CAAA,GAClCC,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEH,GAAG,CAAClB,IAAI,GAAGsB,EAAEJ,GAAG,CAAClB,IAAI,IAAIqB,EAAEF,KAAK,GAAGG,EAAEH,KAAK,EAC3DF,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA;AACtB"}

package/src/lib/app-utils/bundle-intent.d.ts

@@ -0,0 +1,186 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * THE ADD-ONS A PLAN SELLS, AND THE BUNDLE A LINK ASKS FOR (AGL-3955).
+ *
+ * One list of add-on kinds and one parser for the add-ons a link, an upgrade
+ * proposal or a staff dialog names, so the Billing card, the bundle checkout
+ * link, the hand-off proposal (AGL-3956) and `/api/billing/checkout` agree on
+ * what `addons=siteCare,ai,extraHost:2` means.
+ *
+ * The kinds are `OrgSeatAddons`' keys: what `resolvePurchasedAddons` counts,
+ * what the webhook mirrors from Stripe, and what `/api/billing/addons` sells.
+ * The prices and ceilings here are the ones `billing-addons.ts` (server)
+ * re-exports, so a kind the link can preselect is always a kind the
+ * checkout can price.
+ *
+ * A link is typed by a person and passed through hops nobody controls, so
+ * the parser never throws and never guesses: an unknown token is dropped and
+ * reported, so the page can say so in one line instead of failing.
+ */
+import type { AiTierId, OrgPlan, OrgSeatAddons } from '../foundation/definitions/org-billing.types';
+import { resolveOrgEntitlements } from './plan-entitlements';
+/** An add-on kind: a key of `org.seatAddons`. */
+export type AddonKind = keyof Required<OrgSeatAddons>;
+/**
+ * Every add-on kind Billing sells, in the order the Billing card lists them.
+ * `/api/billing/addons`, the webhook's price map and the native add-ons
+ * screen all read this list.
+ */
+export declare const ADDON_KINDS: readonly AddonKind[];
+/** The org-wide 0/1 kinds: one purchase covers the workspace. */
+export declare const TOGGLE_ADDON_KIND_LIST: readonly AddonKind[];
+export declare function isAddonKind(value: unknown): value is AddonKind;
+/**
+ * Monthly USD per unit for an add-on on a plan (yearly prices are ×12 of
+ * this); null when the plan doesn't sell the kind. Single pricing source
+ * of truth: `PLAN_PRICING`, the three flat add-on constants and `AI_TIERS`
+ * (`tier` as `addonPriceId` reads it; absent, the tier a plan-named purchase
+ * means, `defaultAiTierForPlan`, AGL-3965).
+ */
+export declare function addonUnitUsd(kind: AddonKind, plan: OrgPlan, tier?: AiTierId | null): number | null;
+/**
+ * Max purchasable quantity per kind, from a purchases-free entitlement
+ * resolution (plan defaults + staff overrides only) so the ceiling does not
+ * drift as the org buys: seat/dataset kinds stop at the plan's hard max,
+ * hosts/registers use flat ceilings, the Event Calendar, Aglyn AI and Site
+ * Care are 0/1 toggles. POS registers additionally require the `pos`
+ * feature, and Site Care a plan that sells it (`planSellsSiteCare`), which is
+ * why the plan travels with the baseline.
+ *
+ * One definition for every reader: `/api/billing/addons` asks how many the
+ * org may buy on its plan, a plan change asks how many of what it bought the
+ * new plan can deliver, and a bundle link asks how many it may preselect.
+ */
+export declare function addonMaxForBaseline(kind: AddonKind, baseline: ReturnType<typeof resolveOrgEntitlements>, plan: OrgPlan): number;
+/** The ceiling a PLAN would impose on an add-on kind, purchases excluded. */
+export declare function addonMaxForPlan(kind: AddonKind, plan: OrgPlan): number;
+/** Whether a plan sells an add-on at all: priced, with a ceiling above zero. */
+export declare function planSellsAddon(kind: AddonKind, plan: OrgPlan): boolean;
+/** Quantities by kind, absent kinds meaning none. */
+export type BundleAddons = Partial<Record<AddonKind, number>>;
+/**
+ * What a link writes for each kind. `ai` and `extraHost` are the words the
+ * account owner chose (AGL-3955); the rest follow the same shape.
+ */
+export declare const BUNDLE_ADDON_TOKENS: Record<AddonKind, string>;
+/** One add-on a token names, with the Aglyn AI tier when it names one. */
+interface ParsedToken {
+    kind: AddonKind;
+    quantity: number;
+    tier?: AiTierId;
+}
+/**
+ * THE `ai:<tier>` TOKENS (AGL-3965).
+ *
+ * Aglyn AI is a tier chosen on its own, on any paid plan: `ai:boost` adds
+ * Aglyn AI Boost. The words are the tier ids, lower-cased as every token is,
+ * and resolve through `parseAiTierAddonKey`, the one spelling of the
+ * `ai:<tier>` key. A bare `ai` (or `ai:1`) still means "add it" and sells
+ * the plan's default tier (`defaultAiTierForPlan`). An unknown tier is
+ * dropped with the notice like any other unknown add-on, never read as
+ * "add whichever tier": that would sell a tier nobody chose.
+ */
+export declare const AI_ADDON_TIER_TOKENS: Readonly<Record<string, AiTierId>>;
+export declare function resolveAiAddonTier(tier: string): ParsedToken | null;
+export interface ParsedBundleAddons {
+    addons: BundleAddons;
+    /** The tokens nothing understood, as they were written. */
+    dropped: string[];
+    /** The Aglyn AI tier an `ai:<tier>` token named (AGL-3965), if any. */
+    aiTier?: AiTierId;
+}
+/**
+ * Read the add-ons a link, a proposal or a request names.
+ *
+ * Accepts the link form (`"siteCare,ai,extraHost:2"`), a list of tokens, or a
+ * map of kind → quantity or flag (`{ siteCare: true, hosts: 2 }`, the shape
+ * the native staff screens post from their toggles). Never throws: anything
+ * it cannot read is reported in `dropped` and left out.
+ */
+export declare function parseBundleAddons(input: unknown): ParsedBundleAddons;
+export interface FittedBundleAddons {
+    addons: BundleAddons;
+    /** Kinds the plan does not sell, dropped. */
+    notSold: AddonKind[];
+}
+/**
+ * The add-ons a plan can actually carry: kinds it does not sell are dropped,
+ * quantities are held to its ceiling. What a link preselects on one plan is
+ * re-fitted when the owner picks another, so the checkout is never asked for
+ * something it would refuse.
+ */
+export declare function fitBundleAddonsToPlan(addons: BundleAddons | null | undefined, plan: OrgPlan): FittedBundleAddons;
+/**
+ * The add-ons as the link writes them: `siteCare,ai:boost,extraHost:2`.
+ * Aglyn AI is written with its tier when one is named (AGL-3965), as bare
+ * `ai` otherwise.
+ */
+export declare function bundleAddonsParam(addons: BundleAddons | null | undefined, aiTier?: AiTierId | null): string;
+/** Whether any add-on is asked for. */
+export declare function hasBundleAddons(addons: BundleAddons | null | undefined): boolean;
+/**
+ * How each kind is named to a customer, singular. Aglyn AI carries its tier
+ * when one is named: "Aglyn AI Boost" (AGL-3965).
+ */
+export declare function bundleAddonLabel(kind: AddonKind, brand?: string, aiTier?: AiTierId | null): string;
+/** "Site Care", "2 × Extra site", "Aglyn AI Boost". */
+export declare function describeBundleAddon(kind: AddonKind, quantity: number, brand?: string, aiTier?: AiTierId | null): string;
+/** The longest coupon code a link carries. Stripe codes are far shorter. */
+export declare const BUNDLE_COUPON_MAX = 64;
+/**
+ * A promotion code as a link carries it, or undefined. Only the characters
+ * Stripe allows in a customer-facing code; anything else is not a code
+ * somebody was handed, and is dropped rather than sent to Stripe.
+ *
+ * The code is only APPLIED here. Codes are minted on the staff Coupons page,
+ * which audits them; nothing on this path creates one.
+ */
+export declare function normalizeBundleCoupon(raw: unknown): string | undefined;
+/**
+ * A domain name as a bundle carries it — lower-cased, no scheme, no path —
+ * or undefined. Whether it is for sale and at what price is the registrar's
+ * answer, re-checked at purchase; this only refuses what cannot be a name.
+ */
+export declare function normalizeBundleDomain(raw: unknown): string | undefined;
+/** "$15.99". */
+export declare function formatBundleCents(cents: number): string;
+/**
+ * The domain line a bundle shows (AGL-3955): "example.com — $15.99 first
+ * year, renews yearly at $15.99". The price is the registrar's at the moment
+ * the link was minted; the purchase re-checks it.
+ */
+export declare function bundleDomainLine(domain: {
+    name: string;
+    firstYearCents: number;
+    renewalCents: number;
+}): string;
+/**
+ * The bundle in one line, for an email, a dialog or a snackbar:
+ * "Starter with Site Care and Aglyn AI, billed yearly, code BOOTH25".
+ */
+export declare function describeBundle(bundle: {
+    plan: OrgPlan;
+    addons?: BundleAddons | null;
+    interval?: 'month' | 'year' | null;
+    coupon?: string | null;
+    /** The Aglyn AI tier, named with the AI add-on (AGL-3965). */
+    aiTier?: AiTierId | null;
+}, options?: {
+    brand?: string;
+}): string;
+export {};