waha-shared 1.0.527 → 1.0.529

package/dist/functions/resend.d.ts

@@ -0,0 +1,153 @@
+import { type ErrorResponse as ResendErrorResponse } from 'resend';
+import { type DripEmailId, type DripLanguageId, type DripSequenceId } from '../types/resend';
+/**
+ * Rate limits and server errors. Network failures (no status code) aren't
+ * retried: the request may have landed, and repeating a create or an event
+ * send could start an automation twice.
+ */
+export declare function isRetryable(error: Pick<ResendErrorResponse, 'statusCode'>): boolean;
+/** From: https://resend.com/audience/topics */
+export declare enum Topics {
+    Newsletter = "83d566a5-a42d-47e9-85e7-b43fb5b10298"
+}
+export declare enum Segments {
+    /**
+     * App donors who asked for the thank-you sequence (plus donors carried over
+     * from AC).
+     */
+    Donor = "74ee171a-f00b-4a10-94b6-ef8508635ee1",
+    /** Everyone who created an app account (enrolled in the onboarding drip). */
+    AppAccounts = "07e0f635-7e85-4d96-9c31-12a7e34f6869"
+}
+/** From: https://resend.com/automations/events */
+export declare enum Events {
+    AppDonorSequence = "donor_thank_you_sequence",
+    NewsletterWelcome = "newsletter_welcome"
+}
+/** From: https://resend.com/audience/properties */
+export declare enum Properties {
+    /** Set by the donor automation when it runs, so it runs once per contact. */
+    AppDonorSequence = "donor_thank_you_sequence",
+    /**
+     * Set by the welcome automation when it runs, so it runs once per contact.
+     */
+    NewsletterWelcome = "newsletter_welcome",
+    /** The onboarding drip a contact was enrolled in, so it runs once each. */
+    NewAccountSequence = "drip_sequence",
+    /** The language a contact's onboarding drip was sent in. */
+    Language = "language"
+}
+/**
+ * Adds a language id to a base id to create a unique drip identifier. A
+ * sequence's id gives its trigger event (and automation) name; an email's id
+ * gives its template alias.
+ */
+export declare function dripId(baseId: DripSequenceId | DripEmailId, languageId: DripLanguageId): string;
+export declare function isDripLanguage(value: string): value is DripLanguageId;
+/** Splits a single "name" form field into first and last name. */
+export declare function splitName(name?: string): {
+    firstName?: string;
+    lastName?: string;
+};
+/**
+ * Returns the existing contact for an email, or creates one. Existing contacts
+ * are returned untouched, so their newsletter choice and account-wide
+ * unsubscribe are never overridden here. New contacts start off the
+ * newsletter.
+ */
+export declare function upsertResendContact({ token, email, name, }: {
+    token: string;
+    email: string;
+    name?: string;
+}): Promise<{
+    id: string;
+    created: boolean;
+}>;
+/**
+ * Creates a contact for an email the caller already knows isn't one, skipping
+ * the lookup {@link upsertResendContact} makes. The contact starts off the
+ * newsletter. Returns the new contact's id.
+ */
+export declare function createResendContact({ token, email, name, }: {
+    token: string;
+    email: string;
+    name?: string;
+}): Promise<string>;
+/**
+ * Every contact's email, lowercased, or only those in one segment when
+ * `segmentId` is given. Read-only.
+ */
+export declare function listContactEmails(token: string, segmentId?: string): Promise<Set<string>>;
+/** Every segment's id and name. Read-only. */
+export declare function listSegments(token: string): Promise<{
+    id: string;
+    name: string;
+}[]>;
+/** Creates a segment and returns its id. */
+export declare function createSegment(token: string, name: string): Promise<string>;
+/**
+ * Adds or removes the contact for an email in a segment. Adding someone already
+ * in it is harmless, and so is removing someone who isn't.
+ */
+export declare function setSegmentMembership({ token, email, segmentId, member, }: {
+    token: string;
+    email: string;
+    segmentId: string;
+    member: boolean;
+}): Promise<void>;
+/**
+ * Deletes the contact for an email, taking its topic and segment memberships
+ * with it. A missing contact is already deleted, so it isn't an error.
+ */
+export declare function deleteResendContact({ token, email, }: {
+    token: string;
+    email: string;
+}): Promise<void>;
+/**
+ * An explicit newsletter signup. This is fresh consent, so it opts the contact
+ * back in even if they opted out of the newsletter or unsubscribed from
+ * everything before. Bounce suppressions still apply. Also triggers the welcome
+ * email, which the automation sends only once per contact.
+ */
+export declare function subscribeToNewsletter({ token, email, name, }: {
+    token: string;
+    email: string;
+    name?: string;
+}): Promise<void>;
+/**
+ * Starts the donor thank-you sequence for a donor who asked for it and adds
+ * them to the Donor segment. A donor who ticked the newsletter box is also
+ * subscribed to it, without the welcome email. Donors who don't ask for the
+ * sequence aren't added to Resend at all.
+ */
+export declare function enrollInDonorSequence({ token, email, name, newsletter, }: {
+    token: string;
+    email: string;
+    name?: string;
+    newsletter?: boolean;
+}): Promise<void>;
+export type DripEnrollment = {
+    status: 'enrolled';
+} | {
+    status: 'already_enrolled';
+    sequence: string;
+};
+export interface EnrollInDripSequenceParams {
+    token: string;
+    email: string;
+    firstName?: string;
+    sequence: DripSequenceId;
+    languageId: DripLanguageId;
+    /** Whether the user ticked the newsletter box when signing in. */
+    newsletter?: boolean;
+}
+/**
+ * Enrolls an app user in a localized drip sequence: adds them to the App
+ * Accounts segment and fires the event that starts that sequence and
+ * language's automation (provisioned by waha-website's
+ * `scripts/emailDrip/push.ts`). A contact already enrolled in any sequence is
+ * left alone, so each person gets at most one drip. A user who ticked the
+ * newsletter box is also subscribed to it: without the welcome email when
+ * their drip starts now, and as an explicit signup when it already ran.
+ */
+export declare function enrollInDripSequence({ token, email, firstName, sequence, languageId, newsletter, }: EnrollInDripSequenceParams): Promise<DripEnrollment>;

package/dist/functions/resend.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Properties = exports.Events = exports.Segments = exports.Topics = void 0;
+exports.isRetryable = isRetryable;
+exports.dripId = dripId;
+exports.isDripLanguage = isDripLanguage;
+exports.splitName = splitName;
+exports.upsertResendContact = upsertResendContact;
+exports.createResendContact = createResendContact;
+exports.listContactEmails = listContactEmails;
+exports.listSegments = listSegments;
+exports.createSegment = createSegment;
+exports.setSegmentMembership = setSegmentMembership;
+exports.deleteResendContact = deleteResendContact;
+exports.subscribeToNewsletter = subscribeToNewsletter;
+exports.enrollInDonorSequence = enrollInDonorSequence;
+exports.enrollInDripSequence = enrollInDripSequence;
+const resend_1 = require("resend");
+const resend_2 = require("../types/resend");
+const utils_1 = require("./utils");
+/**
+ * Rate limits and server errors. Network failures (no status code) aren't
+ * retried: the request may have landed, and repeating a create or an event
+ * send could start an automation twice.
+ */
+function isRetryable(error) {
+    const status = error.statusCode;
+    return status !== null && (status === 429 || status >= 500);
+}
+/** Makes a Resend call, retrying transient failures twice with backoff. */
+async function withRetry(call) {
+    for (let attempt = 1;; attempt++) {
+        const result = await call();
+        if (!result.error || !isRetryable(result.error) || attempt === 3)
+            return result;
+        await new Promise((resolve) => setTimeout(resolve, attempt * 500));
+    }
+}
+/**
+ * The Resend SDK resolves to `{ data, error }` instead of throwing, so an
+ * unchecked call fails silently and the next step gets `undefined`.
+ */
+function verify(result, context) {
+    if (result.error)
+        throw new Error(`${context}: ${result.error.message}`);
+    if (!result.data)
+        throw new Error(`${context}: Resend returned no data.`);
+    return result.data;
+}
+/** From: https://resend.com/audience/topics */
+var Topics;
+(function (Topics) {
+    Topics["Newsletter"] = "83d566a5-a42d-47e9-85e7-b43fb5b10298";
+})(Topics || (exports.Topics = Topics = {}));
+/* From: https://resend.com/audience/segments */
+var Segments;
+(function (Segments) {
+    /**
+     * App donors who asked for the thank-you sequence (plus donors carried over
+     * from AC).
+     */
+    Segments["Donor"] = "74ee171a-f00b-4a10-94b6-ef8508635ee1";
+    /** Everyone who created an app account (enrolled in the onboarding drip). */
+    Segments["AppAccounts"] = "07e0f635-7e85-4d96-9c31-12a7e34f6869";
+})(Segments || (exports.Segments = Segments = {}));
+/** From: https://resend.com/automations/events */
+var Events;
+(function (Events) {
+    Events["AppDonorSequence"] = "donor_thank_you_sequence";
+    Events["NewsletterWelcome"] = "newsletter_welcome";
+    // Drip sequence events are per language and thus generated dynamically, so
+    // they aren't in this enum.
+})(Events || (exports.Events = Events = {}));
+/** From: https://resend.com/audience/properties */
+var Properties;
+(function (Properties) {
+    /** Set by the donor automation when it runs, so it runs once per contact. */
+    Properties["AppDonorSequence"] = "donor_thank_you_sequence";
+    /**
+     * Set by the welcome automation when it runs, so it runs once per contact.
+     */
+    Properties["NewsletterWelcome"] = "newsletter_welcome";
+    /** The onboarding drip a contact was enrolled in, so it runs once each. */
+    Properties["NewAccountSequence"] = "drip_sequence";
+    /** The language a contact's onboarding drip was sent in. */
+    Properties["Language"] = "language";
+})(Properties || (exports.Properties = Properties = {}));
+/**
+ * Adds a language id to a base id to create a unique drip identifier. A
+ * sequence's id gives its trigger event (and automation) name; an email's id
+ * gives its template alias.
+ */
+function dripId(baseId, languageId) {
+    return `${baseId}_${languageId}`;
+}
+function isDripLanguage(value) {
+    return resend_2.DRIP_LANGUAGES.includes(value);
+}
+/** Splits a single "name" form field into first and last name. */
+function splitName(name) {
+    const [firstName, ...rest] = (name ?? '').trim().split(/\s+/);
+    return {
+        firstName: firstName || undefined,
+        lastName: rest.join(' ') || undefined,
+    };
+}
+/**
+ * Returns the existing contact for an email, or creates one. Existing contacts
+ * are returned untouched, so their newsletter choice and account-wide
+ * unsubscribe are never overridden here. New contacts start off the
+ * newsletter.
+ */
+async function upsertResendContact({ token, email, name, }) {
+    const resend = new resend_1.Resend(token);
+    const normalized = (0, utils_1.lower)(email);
+    const existing = await withRetry(() => resend.contacts.get({ email: normalized }));
+    if (existing.data)
+        return { id: existing.data.id, created: false };
+    if (existing.error?.name !== 'not_found')
+        verify(existing, `Looking up contact ${normalized}`);
+    return {
+        id: await createResendContact({ token, email, name }),
+        created: true,
+    };
+}
+/**
+ * Creates a contact for an email the caller already knows isn't one, skipping
+ * the lookup {@link upsertResendContact} makes. The contact starts off the
+ * newsletter. Returns the new contact's id.
+ */
+async function createResendContact({ token, email, name, }) {
+    const resend = new resend_1.Resend(token);
+    const normalized = (0, utils_1.lower)(email);
+    return verify(await withRetry(() => resend.contacts.create({ email: normalized, ...splitName(name) })), `Creating contact ${normalized}`).id;
+}
+/**
+ * Every contact's email, lowercased, or only those in one segment when
+ * `segmentId` is given. Read-only.
+ */
+async function listContactEmails(token, segmentId) {
+    const resend = new resend_1.Resend(token);
+    const emails = new Set();
+    for (let after;;) {
+        const page = verify(await withRetry(() => resend.contacts.list({
+            limit: 100,
+            ...(segmentId && { segmentId }),
+            ...(after && { after }),
+        })), `Listing contacts${segmentId ? ` in segment ${segmentId}` : ''} after ${after ?? 'the start'}`);
+        for (const contact of page.data)
+            emails.add((0, utils_1.lower)(contact.email));
+        const last = page.data[page.data.length - 1];
+        if (!page.has_more || !last)
+            return emails;
+        after = last.id;
+    }
+}
+/** Every segment's id and name. Read-only. */
+async function listSegments(token) {
+    const resend = new resend_1.Resend(token);
+    const segments = [];
+    for (let after;;) {
+        const page = verify(await withRetry(() => resend.segments.list({ limit: 100, ...(after && { after }) })), `Listing segments after ${after ?? 'the start'}`);
+        for (const { id, name } of page.data)
+            segments.push({ id, name });
+        const last = page.data[page.data.length - 1];
+        if (!page.has_more || !last)
+            return segments;
+        after = last.id;
+    }
+}
+/** Creates a segment and returns its id. */
+async function createSegment(token, name) {
+    const resend = new resend_1.Resend(token);
+    return verify(await withRetry(() => resend.segments.create({ name })), `Creating segment "${name}"`).id;
+}
+/**
+ * Adds or removes the contact for an email in a segment. Adding someone already
+ * in it is harmless, and so is removing someone who isn't.
+ */
+async function setSegmentMembership({ token, email, segmentId, member, }) {
+    const resend = new resend_1.Resend(token);
+    const options = { email: (0, utils_1.lower)(email), segmentId };
+    if (member) {
+        verify(await withRetry(() => resend.contacts.segments.add(options)), `Adding ${options.email} to segment ${segmentId}`);
+        return;
+    }
+    const result = await withRetry(() => resend.contacts.segments.remove(options));
+    if (result.error?.name === 'not_found')
+        return;
+    verify(result, `Removing ${options.email} from segment ${segmentId}`);
+}
+/**
+ * Deletes the contact for an email, taking its topic and segment memberships
+ * with it. A missing contact is already deleted, so it isn't an error.
+ */
+async function deleteResendContact({ token, email, }) {
+    const resend = new resend_1.Resend(token);
+    const normalized = (0, utils_1.lower)(email);
+    const result = await withRetry(() => resend.contacts.remove({ email: normalized }));
+    if (result.error?.name === 'not_found')
+        return;
+    verify(result, `Deleting contact ${normalized}`);
+}
+/**
+ * An explicit newsletter signup. This is fresh consent, so it opts the contact
+ * back in even if they opted out of the newsletter or unsubscribed from
+ * everything before. Bounce suppressions still apply. Also triggers the welcome
+ * email, which the automation sends only once per contact.
+ */
+async function subscribeToNewsletter({ token, email, name, }) {
+    const resend = new resend_1.Resend(token);
+    // Upsert the contact.
+    const contact = await upsertResendContact({ token, email, name });
+    // If contact exists, resubscribe them in case they previously unsubscribed.
+    if (!contact.created)
+        verify(await withRetry(() => resend.contacts.update({ id: contact.id, unsubscribed: false })), `Resubscribing contact ${contact.id}`);
+    // Add them to the newsletter topic.
+    verify(await withRetry(() => resend.contacts.topics.update({
+        id: contact.id,
+        topics: [{ id: Topics.Newsletter, subscription: 'opt_in' }],
+    })), `Subscribing contact ${contact.id} to the newsletter`);
+    // Send them a welcome email.
+    verify(await withRetry(() => resend.events.send({
+        event: Events.NewsletterWelcome,
+        contactId: contact.id,
+    })), `Sending ${Events.NewsletterWelcome} for contact ${contact.id}`);
+}
+/** Adds a contact to a segment. Adding someone already in it is harmless. */
+async function addToSegment(resend, contactId, segmentId) {
+    verify(await withRetry(() => resend.contacts.segments.add({ contactId, segmentId })), `Adding contact ${contactId} to segment ${segmentId}`);
+}
+/**
+ * Opts a contact who ticked the newsletter box alongside another signup (an
+ * app account or a donation) in to the newsletter, without the welcome email:
+ * the sequence they're starting already welcomes them. For a contact that
+ * signup just created, the welcome's run-once property is set so a later
+ * explicit signup doesn't send it either. An existing contact's is left alone,
+ * since it may record a welcome they really got.
+ *
+ * Never throws: the sequence has already started, so a failure here is logged
+ * instead of failing the request.
+ */
+async function subscribeAlongsideSequence(resend, contactId, created) {
+    const subscribed = await withRetry(() => resend.contacts.topics.update({
+        id: contactId,
+        topics: [{ id: Topics.Newsletter, subscription: 'opt_in' }],
+    }));
+    if (subscribed.error) {
+        console.error(`Subscribing contact ${contactId} to the newsletter failed:`, subscribed.error);
+        return;
+    }
+    if (!created)
+        return;
+    const marked = await withRetry(() => resend.contacts.update({
+        id: contactId,
+        properties: {
+            [Properties.NewsletterWelcome]: `skipped|${new Date().toISOString()}`,
+        },
+    }));
+    if (marked.error)
+        console.error(`Marking contact ${contactId} welcomed failed:`, marked.error);
+}
+/**
+ * Starts the donor thank-you sequence for a donor who asked for it and adds
+ * them to the Donor segment. A donor who ticked the newsletter box is also
+ * subscribed to it, without the welcome email. Donors who don't ask for the
+ * sequence aren't added to Resend at all.
+ */
+async function enrollInDonorSequence({ token, email, name, newsletter, }) {
+    const resend = new resend_1.Resend(token);
+    const { id, created } = await upsertResendContact({ token, email, name });
+    await addToSegment(resend, id, Segments.Donor);
+    verify(await withRetry(() => resend.events.send({
+        event: Events.AppDonorSequence,
+        contactId: id,
+    })), `Sending ${Events.AppDonorSequence} for contact ${id}`);
+    if (newsletter)
+        await subscribeAlongsideSequence(resend, id, created);
+}
+/**
+ * Enrolls an app user in a localized drip sequence: adds them to the App
+ * Accounts segment and fires the event that starts that sequence and
+ * language's automation (provisioned by waha-website's
+ * `scripts/emailDrip/push.ts`). A contact already enrolled in any sequence is
+ * left alone, so each person gets at most one drip. A user who ticked the
+ * newsletter box is also subscribed to it: without the welcome email when
+ * their drip starts now, and as an explicit signup when it already ran.
+ */
+async function enrollInDripSequence({ token, email, firstName, sequence, languageId, newsletter, }) {
+    const resend = new resend_1.Resend(token);
+    const normalized = (0, utils_1.lower)(email);
+    const existing = await withRetry(() => resend.contacts.get({ email: normalized }));
+    if (existing.error?.name !== 'not_found' && !existing.data)
+        verify(existing, `Looking up contact ${normalized}`);
+    const contact = existing.data;
+    const enrolledIn = contact?.properties?.[Properties.NewAccountSequence]?.value;
+    if (enrolledIn) {
+        // No drip starts to welcome them, so this is an ordinary signup.
+        if (newsletter)
+            await subscribeToNewsletter({ token, email, name: firstName }).catch((e) => console.error(`Subscribing ${normalized} to the newsletter failed:`, e));
+        return { status: 'already_enrolled', sequence: `${enrolledIn}` };
+    }
+    /*
+     * The sequence property is deliberately not set yet. Marking a contact
+     * enrolled before the event below fires would strand them if it failed: the
+     * check above would skip them forever though their drip never started.
+     */
+    const properties = { [Properties.Language]: languageId };
+    const id = contact
+        ? verify(await withRetry(() => resend.contacts.update({ id: contact.id, firstName, properties })), `Updating contact ${contact.id}`).id
+        : verify(await withRetry(() => resend.contacts.create({ email: normalized, firstName, properties })), `Creating contact ${normalized}`).id;
+    await addToSegment(resend, id, Segments.AppAccounts);
+    const event = dripId(sequence, languageId);
+    verify(await withRetry(() => resend.events.send({ event, contactId: id })), `Sending ${event} for contact ${id}`);
+    /*
+     * The drip has started, so a failure here only weakens the guard against a
+     * second enrollment. It's logged rather than failing a request that
+     * otherwise succeeded.
+     */
+    const marked = await withRetry(() => resend.contacts.update({
+        id,
+        properties: { [Properties.NewAccountSequence]: sequence },
+    }));
+    if (marked.error)
+        console.error(`Marking contact ${id} enrolled failed:`, marked.error);
+    if (newsletter)
+        await subscribeAlongsideSequence(resend, id, !contact);
+    return { status: 'enrolled' };
+}

package/dist/functions/utils.d.ts

@@ -7,3 +7,4 @@ export declare function getErrorInfo(e: unknown): {
     code?: string;
     message?: string;
 };
+export declare function lower(string: string): string;

package/dist/functions/utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dirname = exports.first = exports.basename = exports.join = void 0;
 exports.getErrorInfo = getErrorInfo;
+exports.lower = lower;
 const join = (...parts) => parts.join('/').replace(/\/+/g, '/');
 exports.join = join;
 const basename = (p) => p.slice(p.lastIndexOf('/') + 1);
@@ -21,3 +22,6 @@ function getErrorInfo(e) {
     const message = e instanceof Error ? e.message : undefined;
     return { code, message };
 }
+function lower(string) {
+    return string.trim().toLowerCase();
+}

package/dist/types/dripSequence.d.ts

@@ -18,11 +18,7 @@ export declare const SubscribeDripBody: z.ZodObject<{
         drip_believer: "drip_believer";
         drip_seeker: "drip_seeker";
     }>;
-    languageId: z.ZodEnum<{
-        eng: "eng";
-        ara: "ara";
-        swe: "swe";
-    }>;
+    languageId: z.ZodString;
     firstName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type SubscribeDripBody = z.infer<typeof SubscribeDripBody>;

package/dist/types/dripSequence.js

@@ -12,6 +12,6 @@ exports.DRIP_LANGUAGES = ['eng', 'ara', 'swe'];
 exports.DripLanguageId = zod_1.default.enum(exports.DRIP_LANGUAGES);
 exports.SubscribeDripBody = zod_1.default.object({
     sequence: exports.DripSequenceId,
-    languageId: exports.DripLanguageId,
+    languageId: zod_1.default.string(),
     firstName: zod_1.default.string().optional(),
 });

package/dist/types/languages.d.ts

@@ -55,6 +55,12 @@ export declare const LanguageInfoStatuses: z.ZodObject<{
         testing: "testing";
         launched: "launched";
     }>;
+    drip: z.ZodOptional<z.ZodEnum<{
+        notStarted: "notStarted";
+        inProgress: "inProgress";
+        testing: "testing";
+        launched: "launched";
+    }>>;
     dmCourse: z.ZodEnum<{
         notStarted: "notStarted";
         inProgress: "inProgress";

package/dist/types/logs.d.ts

@@ -1,7 +1,6 @@
 import z from 'zod';
 export declare const WahaShareContent: z.ZodEnum<{
     lesson: "lesson";
-    note: "note";
     lessonLink: "lessonLink";
     setLink: "setLink";
     app: "app";
@@ -21,6 +20,7 @@ export declare const WahaShareContent: z.ZodEnum<{
     scriptureAudio: "scriptureAudio";
     inviteGroup: "inviteGroup";
     offlineVersionLink: "offlineVersionLink";
+    note: "note";
     customSet: "customSet";
     microLesson: "microLesson";
 }>;
@@ -29,7 +29,6 @@ export declare const ShareLogEvent: z.ZodObject<{
     time: z.ZodNumber;
     content: z.ZodEnum<{
         lesson: "lesson";
-        note: "note";
         lessonLink: "lessonLink";
         setLink: "setLink";
         app: "app";
@@ -49,6 +48,7 @@ export declare const ShareLogEvent: z.ZodObject<{
         scriptureAudio: "scriptureAudio";
         inviteGroup: "inviteGroup";
         offlineVersionLink: "offlineVersionLink";
+        note: "note";
         customSet: "customSet";
         microLesson: "microLesson";
     }>;

package/dist/types/resend.d.ts

@@ -0,0 +1,60 @@
+import z from 'zod';
+import type { Status } from '../data/languages/languages.zod';
+/** The two onboarding drip audiences a new signup can be enrolled in. */
+export declare const DripSequenceId: z.ZodEnum<{
+    drip_believer: "drip_believer";
+    drip_seeker: "drip_seeker";
+}>;
+export type DripSequenceId = z.infer<typeof DripSequenceId>;
+/** Ids of languages whose `status.drip` in languages.json is one of these. */
+export declare function dripLanguagesWithStatus(...statuses: Status[]): string[];
+/**
+ * Languages the onboarding drip is live in: provisioned in Resend and enrolled
+ * into on signup. Driven by `status.drip` in languages.json.
+ */
+export declare const DRIP_LANGUAGES: string[];
+export declare const DripLanguageId: z.ZodString;
+export type DripLanguageId = z.infer<typeof DripLanguageId>;
+/**
+ * A single drip email's id: its sequence's id plus its position. The same as
+ * the file name for the email's source .md file.
+ */
+export type DripEmailId = `${DripSequenceId}_${number}`;
+/** `POST /api/submit-subscribe` (form data): an explicit newsletter signup. */
+export declare const NewsletterSignupBody: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NewsletterSignupBody = z.infer<typeof NewsletterSignupBody>;
+/** `POST /api/submit-contact` (form data): the website's contact form. */
+export declare const ContactFormBody: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    name: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ContactFormBody = z.infer<typeof ContactFormBody>;
+/**
+ * `POST /api/add-to-donation-sequence` (JSON): starts the donor thank-you
+ * drip.
+ */
+export declare const DonorSequenceBody: z.ZodObject<{
+    email: z.ZodPipe<z.ZodString, z.ZodEmail>;
+    name: z.ZodOptional<z.ZodString>;
+    newsletter: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type DonorSequenceBody = z.infer<typeof DonorSequenceBody>;
+/**
+ * `POST /api/subscribe-drip` (JSON, Firebase ID token). Any language is
+ * accepted so callers don't need to know which ones have a drip; unsupported
+ * ones are a no-op.
+ */
+export declare const SubscribeDripBody: z.ZodObject<{
+    sequence: z.ZodEnum<{
+        drip_believer: "drip_believer";
+        drip_seeker: "drip_seeker";
+    }>;
+    languageId: z.ZodString;
+    firstName: z.ZodOptional<z.ZodString>;
+    newsletter: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SubscribeDripBody = z.infer<typeof SubscribeDripBody>;