@openlup/platform 0.16.0 → 0.17.0

package/dist/communications/emailTransport.js

@@ -0,0 +1,95 @@
+import { admitPolicyEnforcedEmailTransport } from "./emailEgress.js";
+/** Converts the transport's legacy identifier field at the transport boundary. */
+export function emailTransportMessageId(outcome) {
+    return outcome.resendId;
+}
+/** Maps the neutral message identifier onto the deployed ledger's legacy field. */
+export function emailTransportLedgerIdentifier(messageId) {
+    return { resend_id: messageId };
+}
+/** Synthesizes the canonical terminal transport shape when `send` throws. */
+export function failedEmailTransportResult() {
+    return {
+        outcome: { ok: false, resendId: null, httpStatus: 0, providerError: "provider_transport_threw", aborted: false },
+        providerResponse: { exception: true },
+    };
+}
+/** One truth projection for every Node email ledger, timeline and caller. */
+export function classifyEmailSendOutcome(outcome) {
+    const skipReason = outcome.skipReason
+        ?? (outcome.adminDisabled ? "admin_disabled" : null)
+        ?? (outcome.suppressed === "drop" ? "egress_suppressed" : null);
+    if (skipReason) {
+        return {
+            skipReason,
+            timelineStatus: "skipped",
+            ledgerStatus: "skipped",
+            sentAtEligible: false,
+            lastErrorCode: skipReason,
+        };
+    }
+    // `ok` deliberately remains the transport-acceptance contract. In particular,
+    // this wave does not turn a historical 2xx-without-id answer into a retry.
+    if (outcome.ok) {
+        return {
+            skipReason: null,
+            timelineStatus: "sent",
+            ledgerStatus: "sent",
+            sentAtEligible: true,
+            lastErrorCode: null,
+        };
+    }
+    if (outcome.aborted) {
+        return {
+            skipReason: null,
+            timelineStatus: "delivery_delayed",
+            ledgerStatus: "failed",
+            sentAtEligible: false,
+            lastErrorCode: "provider_request_aborted",
+        };
+    }
+    return {
+        skipReason: null,
+        timelineStatus: "failed",
+        ledgerStatus: "failed",
+        sentAtEligible: false,
+        lastErrorCode: normalizeEmailFailureCode(outcome.providerError),
+    };
+}
+/** Adds a provider-neutral skip reason without changing ordinary wire shapes. */
+export function withEmailSendSkipReason(outcome) {
+    const skipReason = classifyEmailSendOutcome(outcome).skipReason;
+    return skipReason ? { ...outcome, skipReason } : outcome;
+}
+function normalizeEmailFailureCode(value) {
+    if (!value)
+        return "provider_send_failed";
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 80);
+    return normalized || "provider_send_failed";
+}
+/**
+ * Reference capture transport: captures sends in memory and never makes a
+ * network call. Proves the seam is real — a port wired to this sends email with
+ * no HTTP client — and doubles as the substitute an OSS fork starts from
+ * before writing its own SES/SMTP adapter.
+ */
+export function createInMemoryEmailTransport(opts) {
+    const sent = [];
+    const prefix = opts?.idPrefix ?? "in-memory";
+    return admitPolicyEnforcedEmailTransport({
+        providerKind: "in-memory",
+        sent,
+        async send(message) {
+            sent.push(message);
+            const id = `${prefix}-${sent.length}`;
+            return {
+                outcome: { ok: true, resendId: id, httpStatus: 200, providerError: null, aborted: false },
+                providerResponse: { id },
+            };
+        },
+    });
+}

package/dist/communications/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class CommunicationRecipientNotFoundError extends Error {
+    constructor(message?: string);
+}
+export declare class CommunicationTemplateNotFoundError extends Error {
+    constructor(message?: string);
+}
+export declare class CommunicationConflictError extends Error {
+    constructor(message?: string);
+}
+export declare class CommunicationValidationError extends Error {
+    constructor(message?: string);
+}
+export declare class CommunicationUnavailableError extends Error {
+    constructor(message?: string);
+}

package/dist/communications/errors.js

@@ -0,0 +1,30 @@
+export class CommunicationRecipientNotFoundError extends Error {
+    constructor(message = "Communication recipient not found") {
+        super(message);
+        this.name = "CommunicationRecipientNotFoundError";
+    }
+}
+export class CommunicationTemplateNotFoundError extends Error {
+    constructor(message = "Communication template not found") {
+        super(message);
+        this.name = "CommunicationTemplateNotFoundError";
+    }
+}
+export class CommunicationConflictError extends Error {
+    constructor(message = "Communication request conflicts with current state") {
+        super(message);
+        this.name = "CommunicationConflictError";
+    }
+}
+export class CommunicationValidationError extends Error {
+    constructor(message = "Communication request is invalid") {
+        super(message);
+        this.name = "CommunicationValidationError";
+    }
+}
+export class CommunicationUnavailableError extends Error {
+    constructor(message = "Communication capability is unavailable") {
+        super(message);
+        this.name = "CommunicationUnavailableError";
+    }
+}

package/dist/communications/index.d.ts

@@ -0,0 +1,46 @@
+export * from "./accountingDocumentDelivery.js";
+export * from "./authEmailError.js";
+export * from "./authSendEmailHook.js";
+export * from "./capturedTransactionalDelivery.js";
+export * from "./communicationSync.js";
+export * from "./communicationSyncWorker.js";
+export * from "./consentPolicy.js";
+export * from "./deliveryReconciliation.js";
+export * from "./contribution.js";
+export * from "./emailHealthAssessment.js";
+export * from "./emailHealthMetricsPort.js";
+export * from "./emailNotificationControl.js";
+export * from "./emailObservation.js";
+export * from "./emailTransport.js";
+export * from "./emailEgress.js";
+export * from "./errors.js";
+export * from "./integrationEventSignature.js";
+export * from "./managedTransactionalDeliveryStore.js";
+export * from "./newsletterIntegrationContracts.js";
+export * from "./newsletterWebhookPort.js";
+export * from "./originPolicy.js";
+export * from "./postgresTransactionalDeliveryStore.js";
+export * from "./preferencesToken.js";
+export * from "./publicPreferenceToken.js";
+export * from "./shipmentNotifications.js";
+export * from "./sql.js";
+export * from "./standardWebhooks.js";
+export * from "./status.js";
+export * from "./transactionalDelivery.js";
+export * from "./transactionalDeliveryIdentifier.js";
+export * from "./unsubscribeToken.js";
+export type * from "./contracts/authEmail.js";
+export type * from "./contracts/email.js";
+export type * from "./contracts/publicIntake.js";
+export type * from "./contracts/transactionalDelivery.js";
+export type * from "./contracts/newsletterWebhook.js";
+export type { NewsletterSyncProviderPort, NewsletterSyncOutcome, NewsletterSyncReconcileOutcome } from "./contracts/newsletter.js";
+export * from "./consentPurposeRegistry.js";
+export type * from "./contracts/consent.js";
+export type * from "./contracts/marketingAutomation.js";
+export * from "./newsletterWebhookProcessing.js";
+export * from "./nativeOperations.js";
+export * from "./postgresDeliveryReconciliation.js";
+export * from "./postgresCommunicationSync.js";
+export * from "./postgresNotificationRecipients.js";
+export * from "./postgresConsentEvaluator.js";

package/dist/communications/index.js

@@ -0,0 +1,38 @@
+export * from "./accountingDocumentDelivery.js";
+export * from "./authEmailError.js";
+export * from "./authSendEmailHook.js";
+export * from "./capturedTransactionalDelivery.js";
+export * from "./communicationSync.js";
+export * from "./communicationSyncWorker.js";
+export * from "./consentPolicy.js";
+export * from "./deliveryReconciliation.js";
+export * from "./contribution.js";
+export * from "./emailHealthAssessment.js";
+export * from "./emailHealthMetricsPort.js";
+export * from "./emailNotificationControl.js";
+export * from "./emailObservation.js";
+export * from "./emailTransport.js";
+export * from "./emailEgress.js";
+export * from "./errors.js";
+export * from "./integrationEventSignature.js";
+export * from "./managedTransactionalDeliveryStore.js";
+export * from "./newsletterIntegrationContracts.js";
+export * from "./newsletterWebhookPort.js";
+export * from "./originPolicy.js";
+export * from "./postgresTransactionalDeliveryStore.js";
+export * from "./preferencesToken.js";
+export * from "./publicPreferenceToken.js";
+export * from "./shipmentNotifications.js";
+export * from "./sql.js";
+export * from "./standardWebhooks.js";
+export * from "./status.js";
+export * from "./transactionalDelivery.js";
+export * from "./transactionalDeliveryIdentifier.js";
+export * from "./unsubscribeToken.js";
+export * from "./consentPurposeRegistry.js";
+export * from "./newsletterWebhookProcessing.js";
+export * from "./nativeOperations.js";
+export * from "./postgresDeliveryReconciliation.js";
+export * from "./postgresCommunicationSync.js";
+export * from "./postgresNotificationRecipients.js";
+export * from "./postgresConsentEvaluator.js";

package/dist/communications/integrationEventSignature.d.ts

@@ -0,0 +1,15 @@
+export declare const COMMUNICATION_INTEGRATION_SIGNATURE_TOLERANCE_SECONDS = 300;
+export declare const COMMUNICATION_INTEGRATION_SIGNATURE_HEADER = "x-openlup-communications-signature";
+export declare const COMMUNICATION_INTEGRATION_TIMESTAMP_HEADER = "x-openlup-communications-timestamp";
+export declare function verifyCommunicationIntegrationEventSignature(input: {
+    rawBody: string;
+    signatureHeader: string | undefined;
+    timestampHeader: string | undefined;
+    secret: string;
+    now?: () => number;
+}): boolean;
+export declare function signCommunicationIntegrationEvent(input: {
+    rawBody: string;
+    timestamp: number;
+    secret: string;
+}): string;

package/dist/communications/integrationEventSignature.js

@@ -0,0 +1,37 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+export const COMMUNICATION_INTEGRATION_SIGNATURE_TOLERANCE_SECONDS = 300;
+export const COMMUNICATION_INTEGRATION_SIGNATURE_HEADER = "x-openlup-communications-signature";
+export const COMMUNICATION_INTEGRATION_TIMESTAMP_HEADER = "x-openlup-communications-timestamp";
+export function verifyCommunicationIntegrationEventSignature(input) {
+    if (!input.secret || !input.signatureHeader || !input.timestampHeader)
+        return false;
+    const timestamp = Number(input.timestampHeader);
+    if (!Number.isFinite(timestamp))
+        return false;
+    const now = input.now ?? (() => Math.floor(Date.now() / 1000));
+    const age = now() - timestamp;
+    if (age > COMMUNICATION_INTEGRATION_SIGNATURE_TOLERANCE_SECONDS)
+        return false;
+    if (age < -COMMUNICATION_INTEGRATION_SIGNATURE_TOLERANCE_SECONDS)
+        return false;
+    const signature = normalizeSignature(input.signatureHeader);
+    const expected = signCommunicationIntegrationEvent({
+        rawBody: input.rawBody,
+        timestamp,
+        secret: input.secret,
+    });
+    return safeEqual(signature, expected);
+}
+export function signCommunicationIntegrationEvent(input) {
+    return createHmac("sha256", input.secret)
+        .update(`${input.timestamp}.${input.rawBody}`)
+        .digest("hex");
+}
+function normalizeSignature(value) {
+    return value.trim().replace(/^sha256=/i, "");
+}
+function safeEqual(left, right) {
+    const leftBuffer = Buffer.from(left);
+    const rightBuffer = Buffer.from(right);
+    return leftBuffer.length === rightBuffer.length && timingSafeEqual(leftBuffer, rightBuffer);
+}

package/dist/communications/managedTransactionalDeliveryStore.d.ts

@@ -0,0 +1,12 @@
+import type { TransactionalDeliveryReceiptStore } from "./contracts/transactionalDelivery.js";
+export interface ManagedTransactionalDeliveryStoreClient {
+    rpc(functionName: string, args: Record<string, unknown>): PromiseLike<{
+        data: unknown;
+        error: {
+            code?: string;
+            message?: string;
+        } | null;
+    }>;
+}
+/** Managed adapter over the three receipt RPCs; access scope belongs to its binding. */
+export declare function createManagedTransactionalDeliveryStore(client: ManagedTransactionalDeliveryStoreClient): TransactionalDeliveryReceiptStore;

package/dist/communications/managedTransactionalDeliveryStore.js

@@ -0,0 +1,49 @@
+function failure(name, error) {
+    const result = new Error(`${name}_failed: ${error.message ?? error.code ?? "unknown"}`);
+    result.code = error.code;
+    return result;
+}
+function receipt(data) {
+    const value = (Array.isArray(data) ? data[0] : data);
+    if (!value || typeof value !== "object")
+        throw new Error("transactional_delivery_receipt_invalid");
+    const common = {
+        idempotencyKey: String(value.idempotency_key ?? ""),
+        commandFingerprint: String(value.command_fingerprint ?? ""),
+        attemptCount: Number(value.attempt_count ?? 0),
+    };
+    if (value.state === "accepted" && typeof value.delivery_reference === "string" && value.error_code == null) {
+        return { ...common, state: "accepted", deliveryReference: value.delivery_reference, errorCode: null };
+    }
+    if (value.state === "failed" && value.delivery_reference == null && typeof value.error_code === "string") {
+        return { ...common, state: "failed", deliveryReference: null, errorCode: value.error_code };
+    }
+    throw new Error("transactional_delivery_receipt_invalid");
+}
+/** Managed adapter over the three receipt RPCs; access scope belongs to its binding. */
+export function createManagedTransactionalDeliveryStore(client) {
+    const call = async (name, args) => {
+        const { data, error } = await client.rpc(name, args);
+        if (error)
+            throw failure(name, error);
+        return receipt(data);
+    };
+    return {
+        async readReceipt(idempotencyKey) {
+            const { data, error } = await client.rpc("transactional_delivery_read_receipt", { p_idempotency_key: idempotencyKey });
+            if (error)
+                throw failure("transactional_delivery_read_receipt", error);
+            return Array.isArray(data) && data.length === 0 ? null : receipt(data);
+        },
+        recordAccepted: (input) => call("transactional_delivery_record_accepted", {
+            p_idempotency_key: input.idempotencyKey,
+            p_command_fingerprint: input.commandFingerprint,
+            p_delivery_reference: input.deliveryReference,
+        }),
+        recordFailed: (input) => call("transactional_delivery_record_failed", {
+            p_idempotency_key: input.idempotencyKey,
+            p_command_fingerprint: input.commandFingerprint,
+            p_error_code: input.errorCode,
+        }),
+    };
+}

package/dist/communications/nativeOperations.d.ts

@@ -0,0 +1,79 @@
+import type { PostgresDataGatewayOptions } from "../data/index.js";
+import type { DeliveryReconciliationPort } from "./deliveryReconciliation.js";
+import type { CommunicationRecipientKind } from "./consentPolicy.js";
+export interface NativeCommunicationsOptions extends PostgresDataGatewayOptions {
+    binding: string;
+}
+export type NativeObservationKind = "sent" | "delayed" | "delivered" | "bounced" | "complained" | "failed";
+export interface NativeNetworkTarget {
+    sourceKey: string;
+    messageId: string;
+    recipientEmail: string;
+    templateReference: string;
+    acceptedAt: string;
+    /** Only a host that observed a real network acceptance may register this fact. */
+    evidence: "network_accepted";
+}
+export interface NativeDeliveryEvidence {
+    id: string;
+    sourceKey: string;
+    messageId: string;
+    acceptedAt: string;
+    observedState: NativeObservationKind | null;
+    observedAt: string | null;
+    lastPollAt: string | null;
+    notFoundCount: number;
+    abandonedAt: string | null;
+    observations: {
+        key: string;
+        kind: NativeObservationKind;
+        occurredAt: string;
+        source: "poll" | "callback";
+    }[];
+}
+export interface NativeDeliveryStore extends DeliveryReconciliationPort {
+    registerNetworkTarget(input: NativeNetworkTarget): Promise<{
+        id: string;
+    }>;
+    applyObservation(input: {
+        sendId: string;
+        messageId: string;
+        observationKey: string;
+        kind: NativeObservationKind;
+        occurredAt: string;
+        recipientEmail: string | null;
+        source: "poll" | "callback";
+    }): Promise<void>;
+    findByMessageId(messageId: string): Promise<{
+        id: string;
+    } | null>;
+    listEvidence(input: {
+        limit: number;
+    }): Promise<NativeDeliveryEvidence[]>;
+    readEvidence(sendId: string): Promise<NativeDeliveryEvidence | null>;
+    close(): Promise<void>;
+}
+export type NativeNotificationType = "packaging_digest" | "new_signup" | "commerce_payment_critical";
+export interface NativeNotificationRecipient {
+    id: string;
+    email: string;
+    name: string | null;
+    active: boolean;
+    notification_type: NativeNotificationType;
+    created_at: string;
+}
+export interface NativeConsentInput {
+    email: string;
+    purpose: string;
+    recipientKind?: CommunicationRecipientKind;
+    sourceTable?: "testers" | "waitlist" | "clients" | "b2b_inquiries" | "notification_recipients";
+    sourceId?: string | null;
+}
+export interface NativeConsentDecision {
+    allowed: boolean;
+    reason: string;
+    decisionId: string;
+}
+export declare class NativeConsentEvaluationUnavailableError extends Error {
+    constructor(cause: unknown);
+}

package/dist/communications/nativeOperations.js

@@ -0,0 +1,3 @@
+export class NativeConsentEvaluationUnavailableError extends Error {
+    constructor(cause) { super("native_consent_evaluation_unavailable", { cause }); this.name = "ConsentEvaluationUnavailableError"; }
+}

package/dist/communications/newsletterIntegrationContracts.d.ts

@@ -0,0 +1,130 @@
+import type { CommunicationPurposeRegistry } from "./contracts/consent.js";
+import { z } from "./validation.js";
+export declare const NEWSLETTER_MARKETING_PURPOSES: readonly ["marketing_launch_offer", "marketing_newsletter"];
+export declare const NEWSLETTER_SYNC_EVENT_TYPES: readonly ["subscribe", "update", "unsubscribe", "suppress"];
+export declare const NEWSLETTER_WEBHOOK_EVENT_TYPES: readonly ["subscribe", "update", "unsubscribe", "suppress", "complaint", "bounce", "email_change", "profile_update", "ignored"];
+export declare const NEWSLETTER_PROVIDER_CAPABILITY_KEYS: readonly ["subscribe", "unsubscribe", "suppress", "unsuppress", "doubleOptIn", "emailChange", "listMembership", "webhookIdempotency", "retryAfter"];
+import type { NewsletterMarketingPurpose } from "./contracts/newsletter.js";
+import type { NewsletterSyncEventType, NewsletterProviderCapabilityKey, NewsletterProviderCapabilities, NewsletterWebhookEvent } from "./contracts/newsletter.js";
+export type { NewsletterProviderKind, NewsletterMarketingPurpose, NewsletterSyncEventType, NewsletterWebhookEventType, NewsletterProviderCapabilityKey, NewsletterProviderCapabilities, NewsletterWebhookEvent, NewsletterSyncEvent } from "./contracts/newsletter.js";
+export declare const defaultNewsletterProviderCapabilities: NewsletterProviderCapabilities;
+export declare const fullNewsletterProviderCapabilities: NewsletterProviderCapabilities;
+export declare const newsletterProviderKindSchema: z.ZodString;
+export declare const newsletterMarketingPurposeSchema: z.ZodEnum<{
+    marketing_launch_offer: "marketing_launch_offer";
+    marketing_newsletter: "marketing_newsletter";
+}>;
+export declare const newsletterSyncEventTypeSchema: z.ZodEnum<{
+    update: "update";
+    subscribe: "subscribe";
+    unsubscribe: "unsubscribe";
+    suppress: "suppress";
+}>;
+export declare const newsletterWebhookEventTypeSchema: z.ZodEnum<{
+    email_change: "email_change";
+    update: "update";
+    subscribe: "subscribe";
+    unsubscribe: "unsubscribe";
+    suppress: "suppress";
+    complaint: "complaint";
+    bounce: "bounce";
+    profile_update: "profile_update";
+    ignored: "ignored";
+}>;
+export declare const newsletterProviderCapabilitiesSchema: z.ZodObject<{
+    subscribe: z.ZodBoolean;
+    unsubscribe: z.ZodBoolean;
+    suppress: z.ZodBoolean;
+    unsuppress: z.ZodBoolean;
+    doubleOptIn: z.ZodBoolean;
+    emailChange: z.ZodBoolean;
+    listMembership: z.ZodBoolean;
+    webhookIdempotency: z.ZodBoolean;
+    retryAfter: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const canonicalNewsletterWebhookEventSchema: z.ZodObject<{
+    providerKind: z.ZodString;
+    providerEventId: z.ZodString;
+    eventType: z.ZodEnum<{
+        email_change: "email_change";
+        update: "update";
+        subscribe: "subscribe";
+        unsubscribe: "unsubscribe";
+        suppress: "suppress";
+        complaint: "complaint";
+        bounce: "bounce";
+        profile_update: "profile_update";
+        ignored: "ignored";
+    }>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    remoteProfileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    remoteListId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    purpose: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        marketing_launch_offer: "marketing_launch_offer";
+        marketing_newsletter: "marketing_newsletter";
+    }>>>;
+    explicitOptInEvidence: z.ZodOptional<z.ZodBoolean>;
+    doubleOptInStatus: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        confirmed: "confirmed";
+        pending: "pending";
+    }>>;
+    occurredAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type CanonicalNewsletterWebhookEvent = z.infer<typeof canonicalNewsletterWebhookEventSchema>;
+export declare function normalizeCanonicalNewsletterWebhookEvent<Purpose extends string = NewsletterMarketingPurpose>(event: Omit<CanonicalNewsletterWebhookEvent, "purpose"> & {
+    purpose?: Purpose | null;
+}): NewsletterWebhookEvent<Purpose>;
+export declare function requiredNewsletterCapabilityForEvent(eventType: NewsletterSyncEventType): NewsletterProviderCapabilityKey;
+export declare function supportsNewsletterSyncEvent(capabilities: NewsletterProviderCapabilities, eventType: NewsletterSyncEventType): boolean;
+/** Explicit registry binding; legacy schemas above retain their two-purpose default. */
+export declare function createNewsletterIntegrationSchemas<Purpose extends string>(registry: CommunicationPurposeRegistry<Purpose>): {
+    purpose: z.ZodCustom<Purpose, Purpose>;
+    webhookEvent: z.ZodObject<{
+        providerKind: z.ZodString;
+        providerEventId: z.ZodString;
+        eventType: z.ZodEnum<{
+            email_change: "email_change";
+            update: "update";
+            subscribe: "subscribe";
+            unsubscribe: "unsubscribe";
+            suppress: "suppress";
+            complaint: "complaint";
+            bounce: "bounce";
+            profile_update: "profile_update";
+            ignored: "ignored";
+        }>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        remoteProfileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        remoteListId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        explicitOptInEvidence: z.ZodOptional<z.ZodBoolean>;
+        doubleOptInStatus: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            confirmed: "confirmed";
+            pending: "pending";
+        }>>;
+        occurredAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        purpose: z.ZodOptional<z.ZodNullable<z.ZodCustom<Purpose, Purpose>>>;
+    }, z.core.$strip>;
+    syncEvent: z.ZodObject<{
+        id: z.ZodString;
+        claimToken: z.ZodString;
+        contactId: z.ZodString;
+        normalizedEmail: z.ZodString;
+        eventType: z.ZodEnum<{
+            update: "update";
+            subscribe: "subscribe";
+            unsubscribe: "unsubscribe";
+            suppress: "suppress";
+        }>;
+        purpose: z.ZodCustom<Purpose, Purpose>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        attemptCount: z.ZodNumber;
+        originProviderKind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        originProviderEventId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        remoteProfileId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        remoteListId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+};