@aglyn/shared-ui-email-campaigns 1.0.0-beta.143

package/src/lib/components/report-figures.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * @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 four figure primitives now live in `@aglyn/shared-ui-jsx` so the forms
+ * report and the email reports share one implementation of "a rate names its
+ * denominator". Re-exported here because the email cards import them from
+ * this path, and a rate that renders differently on two surfaces is the thing
+ * the shared copy exists to prevent.
+ */ export { Figure, percent, RateRow, Section } from "@aglyn/shared-ui-jsx/components/measured-figures.component";
+import { Stack, Typography } from "@mui/material";
+/*
+ * Money stays here. It is not a figure primitive: it carries a currency, and
+ * this surface deliberately refuses to sum two of them into one number.
+ */ export function money(cents, currency) {
+    const amount = cents / 100;
+    try {
+        return new Intl.NumberFormat(undefined, {
+            style: 'currency',
+            currency: currency.toUpperCase()
+        }).format(amount);
+    } catch (unused) {
+        return `${amount.toFixed(2)} ${currency.toUpperCase()}`;
+    }
+}
+/**
+ * One money figure, with the population it is averaged over named.
+ *
+ * The same rule {@link RateRow} enforces for a percentage, applied to an
+ * average — they go wrong the same way. "$0.42 per recipient" is meaningless
+ * without the recipient count, and worse than meaningless when the reader
+ * assumes a different one from the writer.
+ */ export function MoneyPerMessageRow(props) {
+    const { label, figure } = props;
+    return /*#__PURE__*/ _jsxs(Stack, {
+        direction: "row",
+        spacing: 2,
+        sx: {
+            justifyContent: 'space-between',
+            alignItems: 'baseline'
+        },
+        children: [
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "body2",
+                children: label
+            }),
+            figure ? /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                sx: {
+                    alignItems: 'baseline'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        sx: {
+                            fontWeight: 'bold'
+                        },
+                        children: money(figure.cents, figure.currency)
+                    }),
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        children: `${money(figure.numeratorCents, figure.currency)} over ${figure.denominator.toLocaleString()} ${figure.denominatorLabel}`
+                    })
+                ]
+            }) : /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                children: '— not enough recorded to compute'
+            })
+        ]
+    });
+}
+MoneyPerMessageRow.displayName = 'MoneyPerMessageRow';
+/**
+ * One money total, with what it counts named underneath.
+ *
+ * {@link Figure}'s contract in currency: `null` draws a dash and never a
+ * zero, because "no attribution has ever been recorded" and "this campaign
+ * earned nothing" lead a merchant to opposite conclusions about whether to
+ * send another one.
+ */ export function MoneyFigure(props) {
+    return /*#__PURE__*/ _jsxs(Stack, {
+        sx: {
+            minWidth: 140
+        },
+        children: [
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "h6",
+                children: props.cents === null ? '—' : money(props.cents, props.currency)
+            }),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "body2",
+                children: props.label
+            }),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                children: props.cents === null ? 'not recorded' : props.note
+            })
+        ]
+    });
+}
+MoneyFigure.displayName = 'MoneyFigure';
+
+//# sourceMappingURL=report-figures.js.map

package/src/lib/components/report-figures.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/email-campaigns/src/lib/components/report-figures.tsx"],"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 * The four figure primitives now live in `@aglyn/shared-ui-jsx` so the forms\n * report and the email reports share one implementation of \"a rate names its\n * denominator\". Re-exported here because the email cards import them from\n * this path, and a rate that renders differently on two surfaces is the thing\n * the shared copy exists to prevent.\n */\nexport {\n  Figure,\n  percent,\n  RateRow,\n  Section,\n  type MeasuredRate,\n} from '@aglyn/shared-ui-jsx/components/measured-figures.component'\n\nimport { Stack, Typography } from '@mui/material'\nimport type { CampaignMoneyPerMessage } from '../model/campaign-revenue'\nimport { percent as sharedPercent } from '@aglyn/shared-ui-jsx/components/measured-figures.component'\n\n/*\n * Money stays here. It is not a figure primitive: it carries a currency, and\n * this surface deliberately refuses to sum two of them into one number.\n */\nexport function money(cents: number, currency: string): string {\n  const amount = cents / 100\n  try {\n    return new Intl.NumberFormat(undefined, {\n      style: 'currency',\n      currency: currency.toUpperCase(),\n    }).format(amount)\n  } catch {\n    return `${amount.toFixed(2)} ${currency.toUpperCase()}`\n  }\n}\n\n/**\n * One money figure, with the population it is averaged over named.\n *\n * The same rule {@link RateRow} enforces for a percentage, applied to an\n * average — they go wrong the same way. \"$0.42 per recipient\" is meaningless\n * without the recipient count, and worse than meaningless when the reader\n * assumes a different one from the writer.\n */\nexport function MoneyPerMessageRow(props: {\n  label: string\n  figure: CampaignMoneyPerMessage | null\n}) {\n  const { label, figure } = props\n  return (\n    <Stack\n      direction=\"row\"\n      spacing={2}\n      sx={{ justifyContent: 'space-between', alignItems: 'baseline' }}\n    >\n      <Typography variant=\"body2\">{label}</Typography>\n      {figure ? (\n        <Stack direction=\"row\" spacing={1} sx={{ alignItems: 'baseline' }}>\n          <Typography variant=\"body2\" sx={{ fontWeight: 'bold' }}>\n            {money(figure.cents, figure.currency)}\n          </Typography>\n          <Typography variant=\"caption\" color=\"text.secondary\">\n            {`${money(figure.numeratorCents, figure.currency)} over ${figure.denominator.toLocaleString()} ${figure.denominatorLabel}`}\n          </Typography>\n        </Stack>\n      ) : (\n        <Typography variant=\"caption\" color=\"text.secondary\">\n          {'— not enough recorded to compute'}\n        </Typography>\n      )}\n    </Stack>\n  )\n}\nMoneyPerMessageRow.displayName = 'MoneyPerMessageRow'\n\n/**\n * One money total, with what it counts named underneath.\n *\n * {@link Figure}'s contract in currency: `null` draws a dash and never a\n * zero, because \"no attribution has ever been recorded\" and \"this campaign\n * earned nothing\" lead a merchant to opposite conclusions about whether to\n * send another one.\n */\nexport function MoneyFigure(props: {\n  label: string\n  cents: number | null\n  currency: string\n  note: string\n}) {\n  return (\n    <Stack sx={{ minWidth: 140 }}>\n      <Typography variant=\"h6\">\n        {props.cents === null ? '—' : money(props.cents, props.currency)}\n      </Typography>\n      <Typography variant=\"body2\">{props.label}</Typography>\n      <Typography variant=\"caption\" color=\"text.secondary\">\n        {props.cents === null ? 'not recorded' : props.note}\n      </Typography>\n    </Stack>\n  )\n}\nMoneyFigure.displayName = 'MoneyFigure'\n"],"names":["Figure","percent","RateRow","Section","Stack","Typography","money","cents","currency","amount","Intl","NumberFormat","undefined","style","toUpperCase","format","toFixed","MoneyPerMessageRow","props","label","figure","direction","spacing","sx","justifyContent","alignItems","variant","fontWeight","color","numeratorCents","denominator","toLocaleString","denominatorLabel","displayName","MoneyFigure","minWidth","note"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;CAMC,GACD,SACEA,MAAM,EACNC,OAAO,EACPC,OAAO,EACPC,OAAO,QAEF,6DAA4D;AAEnE,SAASC,KAAK,EAAEC,UAAU,QAAQ,gBAAe;AAIjD;;;CAGC,GACD,OAAO,SAASC,MAAMC,KAAa,EAAEC,QAAgB;IACnD,MAAMC,SAASF,QAAQ;IACvB,IAAI;QACF,OAAO,IAAIG,KAAKC,YAAY,CAACC,WAAW;YACtCC,OAAO;YACPL,UAAUA,SAASM,WAAW;QAChC,GAAGC,MAAM,CAACN;IACZ,EAAE,eAAM;QACN,OAAO,GAAGA,OAAOO,OAAO,CAAC,GAAG,CAAC,EAAER,SAASM,WAAW,IAAI;IACzD;AACF;AAEA;;;;;;;CAOC,GACD,OAAO,SAASG,mBAAmBC,KAGlC;IACC,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAE,GAAGF;IAC1B,qBACE,MAACd;QACCiB,WAAU;QACVC,SAAS;QACTC,IAAI;YAAEC,gBAAgB;YAAiBC,YAAY;QAAW;;0BAE9D,KAACpB;gBAAWqB,SAAQ;0BAASP;;YAC5BC,uBACC,MAAChB;gBAAMiB,WAAU;gBAAMC,SAAS;gBAAGC,IAAI;oBAAEE,YAAY;gBAAW;;kCAC9D,KAACpB;wBAAWqB,SAAQ;wBAAQH,IAAI;4BAAEI,YAAY;wBAAO;kCAClDrB,MAAMc,OAAOb,KAAK,EAAEa,OAAOZ,QAAQ;;kCAEtC,KAACH;wBAAWqB,SAAQ;wBAAUE,OAAM;kCACjC,GAAGtB,MAAMc,OAAOS,cAAc,EAAET,OAAOZ,QAAQ,EAAE,MAAM,EAAEY,OAAOU,WAAW,CAACC,cAAc,GAAG,CAAC,EAAEX,OAAOY,gBAAgB,EAAE;;;+BAI9H,KAAC3B;gBAAWqB,SAAQ;gBAAUE,OAAM;0BACjC;;;;AAKX;AACAX,mBAAmBgB,WAAW,GAAG;AAEjC;;;;;;;CAOC,GACD,OAAO,SAASC,YAAYhB,KAK3B;IACC,qBACE,MAACd;QAAMmB,IAAI;YAAEY,UAAU;QAAI;;0BACzB,KAAC9B;gBAAWqB,SAAQ;0BACjBR,MAAMX,KAAK,KAAK,OAAO,MAAMD,MAAMY,MAAMX,KAAK,EAAEW,MAAMV,QAAQ;;0BAEjE,KAACH;gBAAWqB,SAAQ;0BAASR,MAAMC,KAAK;;0BACxC,KAACd;gBAAWqB,SAAQ;gBAAUE,OAAM;0BACjCV,MAAMX,KAAK,KAAK,OAAO,iBAAiBW,MAAMkB,IAAI;;;;AAI3D;AACAF,YAAYD,WAAW,GAAG"}

package/src/lib/model/campaign-container.d.ts

@@ -0,0 +1,359 @@
+/**
+ * @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.
+ */
+/**
+ * A CAMPAIGN IS A CONTAINER; A SEND IS ONE MESSAGE INSIDE IT.
+ *
+ * ## The two collections, and why there are two
+ *
+ * `hosts/{hostId}/campaigns/{sendId}` holds a SEND: one subject, one body,
+ * one audience, one set of counters. That is what the collection has always
+ * held, and it is why the container could not simply be that document grown
+ * new fields.
+ *
+ * **Its ids are load-bearing outside this repo.** Every unsubscribe link that
+ * has ever gone out carries `cid={sendId}`, those emails sit in inboxes
+ * forever, and the `cid` is inside the link's HMAC — so a send id that stops
+ * resolving is an opt-out that stops working, which is a compliance failure
+ * rather than a broken page. `/marketing/campaigns/{sendId}` is likewise
+ * linkable by design: a merchant pastes it into a message about last week's
+ * send.
+ *
+ * So the send collection is left exactly where it is, under exactly its
+ * existing ids, and the container is a new collection above it:
+ * `hosts/{hostId}/emailCampaigns/{campaignId}`. A send joins one by carrying
+ * {@link CAMPAIGN_SEND_CONTAINER_FIELD}; a send written before containers
+ * existed carries nothing, and {@link campaignListRows} presents it as a
+ * container of one rather than hiding it.
+ *
+ * That last property is what makes this migration-free. There is no backfill
+ * to run, no window in which a merchant's history is missing, and no id
+ * rewritten anywhere.
+ *
+ * ## Why the arithmetic is here
+ *
+ * The same reason `campaign-report.ts` gives for the per-send rates: a
+ * denominator chosen in JSX is a denominator nobody tests. Aggregating across
+ * sends adds one problem the single-send report does not have — some sends
+ * recorded a field and others never did — and summing those into one number
+ * silently reports a partial total as a complete one. Every aggregate here
+ * therefore reports how many sends it could measure.
+ */
+import { type CampaignRate, type CampaignStats } from './campaign-report';
+/**
+ * The field on a SEND naming the campaign it belongs to.
+ *
+ * Not `campaignId`: on a send document that name already means the send's own
+ * id — it is what `cid` carries and what the report route addresses — and one
+ * word meaning both would be read into the other on the first edit.
+ */
+export declare const CAMPAIGN_SEND_CONTAINER_FIELD = "emailCampaignId";
+/**
+ * A campaign: the container, not a message.
+ *
+ * Stored at `hosts/{hostId}/emailCampaigns/{campaignId}`.
+ */
+export interface EmailCampaign {
+    $id: string;
+    /** What the merchant called it. */
+    name: string;
+    /** When the campaign window opens. Null for a campaign with no dates. */
+    startAtMs?: number | null;
+    /** When it closes. Null for an open-ended campaign. */
+    endAtMs?: number | null;
+    /** Org email lists this campaign is aimed at, by list id. */
+    listIds?: string[];
+    /**
+     * The stream this campaign's emails open on.
+     *
+     * A DEFAULT, not a constraint. The topic decides who a send skips, what the
+     * preference page linked from the footer highlights, and which stream a
+     * resulting opt-out is recorded against — all facts about one MESSAGE, and
+     * one campaign may legitimately carry a newsletter and a promotion. So the
+     * composer's picker is what the send records; this is what the picker opens
+     * on, which is what stops a "Sales" campaign quietly mailing under
+     * `marketing`.
+     */
+    topicId?: string;
+    createdAtMs?: number;
+    createdBy?: string;
+    deletedAt?: unknown;
+}
+/** One send, as much of it as a list or a rollup needs. */
+export interface CampaignSend {
+    $id: string;
+    subject?: string;
+    /** The audience KIND: `'leads'`, `'members'`, `'segment'`, `'list'`. */
+    audience?: string;
+    /** The list this send addressed, when the kind is `'list'`. */
+    listId?: string;
+    /** The segment this send addressed, when the kind is `'segment'`. */
+    segmentId?: string;
+    /** Which container it belongs to, absent on a send written before them. */
+    emailCampaignId?: string;
+    status?: string;
+    sentAt?: {
+        seconds?: number;
+    } | null;
+    sendAtMs?: number;
+    /**
+     * When the record was minted, stamped by every writer that creates one.
+     *
+     * Absent on a send written before the stamp existed. The lists that draw
+     * drafts beside sends order on it through `emailListTimeMs`, which is why
+     * it is here rather than only on the loose record shape: a draft carries
+     * neither `sentAt` nor `sendAtMs`, so this is the only time it has.
+     */
+    createdAtMs?: number;
+    stats?: CampaignStats;
+    /** How far a send that goes out over several batches has got. */
+    resume?: CampaignResume;
+}
+/**
+ * The batch state the sender writes on an email that is still going out.
+ *
+ * Absent on every send that finished in one batch, and on every send that
+ * predates batching — which is why {@link campaignSendProgress} treats a
+ * missing record as "this is not a batched send" rather than as zero.
+ */
+export interface CampaignResume {
+    /** People the email has resolved and not yet addressed. */
+    remaining?: number;
+    /** Batches it has run. */
+    batch?: number;
+    /** When the next batch may go, ms. Zero when there is not going to be one. */
+    nextAtMs?: number;
+    /** Why it stopped short, when it did. */
+    stop?: string;
+}
+/**
+ * WHAT A SEND IS ACTUALLY DOING, for a row that would otherwise lie.
+ *
+ * An email larger than one send may carry is delivered over several batches,
+ * and between them it is stored as `scheduled` — the state the processor
+ * claims, and the only one that resumes it without a second index and a
+ * second query. Read literally, that is a row saying "not sent yet" about an
+ * email that has already put five hundred messages in five hundred inboxes.
+ *
+ * So the stored fields are not the sentence. This is: it takes the status,
+ * the delivered count and the batch record, and answers what a person needs
+ * to see. Derived at read time and never persisted, exactly as
+ * `campaignWindowState` beside it is, because it is a description of stored
+ * facts and not a fact of its own.
+ *
+ * ## The four states, and which stored shape each one is
+ *
+ * - `pending` — `scheduled`, nothing delivered. A campaign waiting for its
+ *   time. This is what `scheduled` meant before batching and still does.
+ * - `sending` — `scheduled` or `sending` with something delivered and more to
+ *   come. The state this function exists for.
+ * - `sent` — finished, whether in one batch or six.
+ * - `stopped` — finished with people it never addressed: canceled mid-flight,
+ *   failed mid-flight, or stopped by the batch guard. The count is what makes
+ *   this legible rather than alarming — an email that reached 2,400 of 3,000
+ *   and stopped is a different conversation from one that reached nobody.
+ */
+export type CampaignSendProgressState = 'pending' | 'sending' | 'sent' | 'stopped';
+export interface CampaignSendProgress {
+    state: CampaignSendProgressState;
+    /** Messages this email has delivered. */
+    reached: number;
+    /**
+     * The audience it is working through, when one was recorded. Null when the
+     * send never recorded an audience size, which is every send that predates
+     * the figure — reported as null rather than as `reached` so a surface does
+     * not present a floor as a total.
+     */
+    audience: number | null;
+    /** People it has resolved and not yet addressed. */
+    remaining: number;
+    /** Batches it has run. Zero for a send that never batched. */
+    batch: number;
+    /** When the next batch may go, ms. Zero unless {@link state} is `sending`. */
+    nextAtMs: number;
+    /** One line a surface may show verbatim. */
+    label: string;
+}
+export declare function campaignSendProgress(send: CampaignSend | null | undefined): CampaignSendProgress;
+/**
+ * What a ROW says about one email, in one word and one line.
+ *
+ * {@link campaignSendProgress} answers what a send is DOING, and a draft is
+ * not doing anything: it has no status the progress states cover, and — since
+ * an absent status reads as `sent` and a draft has no counters — asking it
+ * about one answers "Sent to 0", which is the worst available sentence about
+ * an email nobody has written yet. So the draft is settled here and
+ * everything else is deferred, unchanged, to the derivation that owns it.
+ *
+ * One helper rather than the same two-line branch on four surfaces. The
+ * campaigns table, the emails list, an email's own page and a campaign's
+ * emails table all draw this, and four copies is how three of them come to
+ * say "Scheduled" about a campaign that has delivered five hundred messages.
+ */
+export type CampaignSendDisplayState = 'draft' | CampaignSendProgressState;
+export interface CampaignSendDisplay {
+    state: CampaignSendDisplayState;
+    /** One line a surface may show verbatim. */
+    label: string;
+    /** The progress underneath, for a surface that wants the figures. */
+    progress: CampaignSendProgress;
+}
+export declare function campaignSendDisplay(send: CampaignSend | null | undefined): CampaignSendDisplay;
+/**
+ * Whether this email is between batches, with more of its audience to reach.
+ *
+ * The one question two controls on an email's page turn on. It is stored as
+ * `scheduled` — the state the processor claims — so a surface reading the
+ * status alone offers "Send now" on a campaign that is already going out, and
+ * `sendNow` re-resolves the WHOLE audience rather than continuing: everyone
+ * already reached would receive a second copy under the same `cid`.
+ */
+export declare function campaignSendIsMidFlight(send: CampaignSend | null | undefined): boolean;
+/**
+ * The lists ONE SEND addressed — which can be narrower than the lists its
+ * campaign is aimed at.
+ *
+ * A campaign holds the lists a merchant plans to reach; each send inside it
+ * picks one audience, and that audience may be a segment or the site's leads
+ * rather than any of them. Answering from the send is therefore the only
+ * honest answer for a send's own detail page.
+ *
+ * An array for a document that stores one id, deliberately: the question
+ * "which lists did this reach" has a plural answer everywhere it is asked,
+ * and a caller that unwraps a single id today is a caller to revisit if a
+ * send ever addresses two.
+ */
+export declare function campaignSendListIds(send: CampaignSend): string[];
+/**
+ * A number summed across sends, with how much of the campaign it covers.
+ *
+ * `value` is `null` when NO send recorded the field — which is not zero, for
+ * the reason `campaign-report.ts` gives at length: an unrecorded delivery
+ * count and a delivery count of zero lead a merchant to opposite conclusions
+ * about their sending domain.
+ *
+ * `recorded` below `sends` means the total is a floor. A campaign whose
+ * older sends predate the delivery webhook has a real number that describes
+ * part of itself, and saying which part is the difference between a total and
+ * a guess.
+ */
+export interface CampaignAggregate {
+    value: number | null;
+    /** Sends that recorded this field. */
+    recorded: number;
+    /** Sends in the campaign. */
+    sends: number;
+}
+/** Every rolled-up figure for one campaign. */
+export interface CampaignRollup {
+    /** Sends that have actually gone out. */
+    sends: number;
+    /** Sends still waiting for their send time, having delivered nothing. */
+    scheduled: number;
+    /**
+     * Sends part way through an audience larger than one batch.
+     *
+     * Counted apart from `scheduled` and from `sends`, because it is neither:
+     * mail has gone out, and more is going to. Both of those are facts a
+     * merchant reading a campaign row needs, and the stored status carries
+     * only the first.
+     */
+    sending: number;
+    /**
+     * Emails that have been created and not yet written or sent.
+     *
+     * Counted apart from `sends` and from `scheduled`, because a draft is
+     * neither: it has mailed nobody, and it is not on the clock to.
+     */
+    drafts: number;
+    addressed: CampaignAggregate;
+    sent: CampaignAggregate;
+    delivered: CampaignAggregate;
+    opens: CampaignAggregate;
+    uniqueOpens: CampaignAggregate;
+    clicks: CampaignAggregate;
+    uniqueClicks: CampaignAggregate;
+    bounced: CampaignAggregate;
+    complained: CampaignAggregate;
+    unsubscribes: CampaignAggregate;
+    /** Distinct openers over delivered, across every send that recorded both. */
+    openRate: CampaignRate | null;
+    /** Distinct clickers over delivered. */
+    clickRate: CampaignRate | null;
+    /** Unsubscribes over delivered. */
+    unsubscribeRate: CampaignRate | null;
+    /** The most recent send time in the campaign, for ordering a list. */
+    lastSentAtMs: number | null;
+}
+/** When a send happened, in epoch milliseconds, or null. */
+export declare function campaignSendAtMs(send: CampaignSend): number | null;
+/**
+ * Rolls a campaign's sends into one set of figures.
+ *
+ * Rates are taken over the sends that recorded BOTH sides, so a campaign
+ * whose first send predates the delivery webhook reports the open rate of the
+ * sends that can be measured rather than one deflated by a send with no
+ * denominator.
+ */
+export declare function campaignRollup(sends: CampaignSend[]): CampaignRollup;
+/**
+ * Where a campaign stands against its own window.
+ *
+ * Derived at read time and never persisted — the `status` values on a SEND
+ * (`sent`, `scheduled`, `canceled`, `failed`) are stored strings that a
+ * processor branches on, and a display state sharing those spellings would
+ * eventually be written back.
+ */
+export type CampaignWindowState = 'undated' | 'upcoming' | 'running' | 'ended';
+export declare function campaignWindowState(campaign: Pick<EmailCampaign, 'startAtMs' | 'endAtMs'>, nowMs: number): CampaignWindowState;
+/** One row of the campaigns table. */
+export interface CampaignListRow {
+    /** The id the detail route resolves — a container id, or a send id. */
+    id: string;
+    name: string;
+    /**
+     * True when this row IS a send with no container.
+     *
+     * A campaign sent before containers existed is shown as a campaign of one
+     * rather than dropped from the list, and the detail route falls back to the
+     * send's own report for it. Nothing about that send is rewritten.
+     */
+    legacy: boolean;
+    startAtMs: number | null;
+    endAtMs: number | null;
+    listIds: string[];
+    sends: CampaignSend[];
+    rollup: CampaignRollup;
+    windowState: CampaignWindowState;
+    /** For ordering: the campaign's start, else its most recent send. */
+    atMs: number | null;
+}
+/**
+ * The campaigns table's rows: every container, plus every send that belongs
+ * to none.
+ *
+ * The second half is what makes the container additive. A merchant's history
+ * is the sends they already have; a list that showed only containers would
+ * read as an empty product on the day this shipped, and a backfill that
+ * adopted each old send into a container of one would rewrite documents whose
+ * ids are cited by mail already delivered. Adopting them AT READ TIME costs a
+ * pass over a list already in memory and rewrites nothing.
+ *
+ * Newest first, on the start date where there is one and the last send
+ * otherwise. Rows with no date at all sort last: they are campaigns nobody
+ * has scheduled or sent, and dating them from nothing would be an invention.
+ */
+export declare function campaignListRows(campaigns: EmailCampaign[], sends: CampaignSend[], nowMs: number): CampaignListRow[];