@riverbankcms/sdk 0.151.0 → 0.153.0

package/dist/_dts/commerce/src/purchase/confirmationPayment.d.ts

@@ -0,0 +1,65 @@
+import { type NonNegativeCents, type Result } from '../../../core/src/index';
+import type { z } from 'zod';
+import { confirmationPaymentSchema, type paymentBalanceSchema } from './confirmationPaymentSchema';
+import { type OrderPaymentPositionInconsistency, type PaymentTerms } from './orderPaymentState';
+import type { OrderPaymentMethod } from './orderTypes';
+import type { CurrencyCode } from './settlement';
+export type PaymentBalance = z.infer<typeof paymentBalanceSchema>;
+export type ConfirmationPayment = z.infer<typeof confirmationPaymentSchema>;
+type MonetaryMethod = Extract<OrderPaymentMethod, 'stripe' | 'store_credit' | 'mixed' | 'manual'>;
+export type ConfirmationPaymentIssue = OrderPaymentPositionInconsistency | Readonly<{
+    kind: 'missing_settlement_evidence';
+}> | Readonly<{
+    kind: 'ambiguous_booking_allocation';
+}> | Readonly<{
+    kind: 'invalid_pass_credits';
+}>;
+export type ConfirmationPaymentInput = Readonly<{
+    kind: 'free' | 'waived';
+}> | Readonly<{
+    kind: 'pass';
+    passName?: string | null;
+    passCreditsUsed?: number | null;
+}> | Readonly<{
+    kind: 'membership';
+    membershipName?: string | null;
+}> | Readonly<{
+    kind: 'monetary';
+    paymentMethod: MonetaryMethod;
+    currency: CurrencyCode;
+    cashDueCents: NonNegativeCents;
+    cashPaidCents: NonNegativeCents;
+    creditPaidCents: NonNegativeCents;
+    waivedCents: NonNegativeCents;
+    terms: PaymentTerms;
+}>;
+/** Public payment evidence returns only schema-valid decisions. Legacy email
+ * snapshots deliberately use the amount calculation below instead of this boundary.
+ */
+export declare function buildConfirmationPayment(input: ConfirmationPaymentInput): Result<ConfirmationPayment, ConfirmationPaymentIssue>;
+export type ConfirmationOrderItem = Readonly<{
+    netTotalCents: number | null;
+    totalCents: number | null;
+    creditCents: number | null;
+}>;
+export declare function settledOrderItemTotalCents(item: ConfirmationOrderItem): number;
+/** Historical notification amounts, not a validated public payment decision.
+ * Preserve HEAD's raw snapshot numbers; strict evidence validation belongs to
+ * the public read boundary, not notification-plan construction (#1587).
+ */
+export declare function calculateOrderItemsConfirmationPaymentAmounts(input: Readonly<{
+    items: readonly ConfirmationOrderItem[];
+    settlement: Readonly<{
+        kind: 'settled_in_full';
+    }> | Readonly<{
+        kind: 'collected';
+        collectedCents: number;
+    }>;
+}>): Readonly<{
+    amountPaidCents: number;
+    amountOutstandingCents: number;
+}>;
+export declare function collectedOrderItemsConfirmationCents<TItem extends Readonly<{
+    id: string;
+}>>(items: readonly TItem[], collectedCentsByOrderItemId: Readonly<Record<string, number>>): number;
+export {};

package/dist/_dts/commerce/src/purchase/confirmationPaymentSchema.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const paymentBalanceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"settled">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"due">;
+    amountCents: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../core/src/index").PositiveCents, number>>;
+    dueAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export declare const confirmationPaymentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"free">;
+    balance: z.ZodObject<{
+        kind: z.ZodLiteral<"settled">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"waived">;
+    balance: z.ZodObject<{
+        kind: z.ZodLiteral<"settled">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"pass">;
+    passName: z.ZodNullable<z.ZodString>;
+    passCreditsUsed: z.ZodNullable<z.ZodNumber>;
+    balance: z.ZodObject<{
+        kind: z.ZodLiteral<"settled">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"membership">;
+    membershipName: z.ZodNullable<z.ZodString>;
+    balance: z.ZodObject<{
+        kind: z.ZodLiteral<"settled">;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"manual_due">;
+    currency: z.ZodPipe<z.ZodString, z.ZodTransform<import("./settlement").CurrencyCode, string>>;
+    balance: z.ZodObject<{
+        kind: z.ZodLiteral<"due">;
+        amountCents: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../core/src/index").PositiveCents, number>>;
+        dueAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    balance: z.ZodObject<{
+        kind: z.ZodLiteral<"due">;
+        amountCents: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../core/src/index").PositiveCents, number>>;
+        dueAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    amountPaidCents: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../core/src/index").NonNegativeCents, number>>;
+    currency: z.ZodPipe<z.ZodString, z.ZodTransform<import("./settlement").CurrencyCode, string>>;
+    kind: z.ZodLiteral<"managed_balance_due">;
+}, z.core.$strict>, z.ZodObject<{
+    paymentMethod: z.ZodEnum<{
+        mixed: "mixed";
+        manual: "manual";
+        stripe: "stripe";
+        store_credit: "store_credit";
+    }>;
+    balance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"settled">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"due">;
+        amountCents: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../core/src/index").PositiveCents, number>>;
+        dueAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+    amountPaidCents: z.ZodPipe<z.ZodNumber, z.ZodTransform<import("../../../core/src/index").NonNegativeCents, number>>;
+    currency: z.ZodPipe<z.ZodString, z.ZodTransform<import("./settlement").CurrencyCode, string>>;
+    kind: z.ZodLiteral<"monetary">;
+}, z.core.$strict>], "kind">;

package/dist/_dts/commerce/src/purchase/index.d.ts

@@ -20,6 +20,8 @@ export * from './checkoutStripeSessionPlanning';
 export * from './checkoutSessionMetadata';
 export * from './canonicalRefundPlanner';
 export * from './confirmationEmailPayment';
+export * from './confirmationPayment';
+export * from './confirmationPaymentSchema';
 export * from './discountApplication';
 export * from './oneTimeCheckoutPlanning';
 export * from './order-number';

package/dist/_dts/commerce/src/purchase/orderPaymentState.d.ts

@@ -111,6 +111,14 @@ export type OrderPaymentPositionInput = Readonly<{
     }> | null;
     hasCollectionFailure?: boolean;
 }>;
+/** Amount arithmetic shared by strict payment evidence and tolerant email snapshots.
+ * Snapshots historically clamp overcollection to zero; the strict decision below
+ * checks collectability before using the same calculation.
+ */
+export declare function calculateOutstandingOrderAmountCents(input: Readonly<{
+    totalCents: number;
+    settledCents: number;
+}>): number;
 export declare function calculateOrderBalanceDueCents(input: Readonly<{
     grandTotalCents: NonNegativeCents;
     paidCents: NonNegativeCents;

package/dist/_dts/content-model/src/content-types/schema.d.ts

@@ -12,14 +12,14 @@ declare const BaseContentFieldSchema: z.ZodObject<{
         text: "text";
         group: "group";
         url: "url";
+        file: "file";
+        datetime: "datetime";
         textarea: "textarea";
         select: "select";
         media: "media";
         reference: "reference";
-        repeater: "repeater";
-        file: "file";
-        datetime: "datetime";
         button: "button";
+        repeater: "repeater";
         richText: "richText";
     }>;
     label: z.ZodOptional<z.ZodString>;

package/dist/_dts/content-model/src/templates/defaults.d.ts

@@ -150,11 +150,11 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
             readonly blockKind: "block.event-registration";
             readonly scope: "entry";
             readonly content: {
-                readonly heading: "Register for this event";
+                readonly heading: "";
                 readonly maxTickets: "5";
                 readonly showVenue: true;
                 readonly showCapacity: true;
-                readonly buttonText: "Complete Registration";
+                readonly buttonText: "Book your place";
                 readonly buttonVariant: "primary";
             };
             readonly bindings: {

package/dist/_dts/core/src/appointment-booking-terms.d.ts

@@ -0,0 +1,20 @@
+import type { BookingPaymentCollectionOption } from './booking-payment-options';
+/** Customer disclosure only: amounts are acceptance ceilings, never settlement inputs. */
+export type AppointmentBookingTerms = Readonly<{
+    currency: string;
+    totalCents: number;
+    dueNowCents: number;
+    laterPaymentAmountsCents: readonly number[];
+    paymentOption: BookingPaymentCollectionOption | Readonly<{
+        kind: 'not_required';
+    }>;
+    promisedDiscountId?: string | null;
+}>;
+export type AppointmentBookingReviewReason = 'amount_increased' | 'payment_terms_changed' | 'discount_unavailable';
+export type AppointmentBookingReview = Readonly<{
+    terms: AppointmentBookingTerms;
+    subtotalCents: number;
+    discountCents: number;
+    creditCents: number;
+    reason: AppointmentBookingReviewReason;
+}>;

package/dist/_dts/core/src/booking-payment-schemas.d.ts

@@ -519,4 +519,74 @@ export declare const bookingPaymentOptionsChoiceSchema: z.ZodDiscriminatedUnion<
         }, z.core.$strip>], "kind">>;
     }, z.core.$strip>;
 }, z.core.$strict>], "source">;
+/** Strict evidence shape; accepts configured rules but no materialised schedule metadata. */
+export declare const appointmentBookingTermsSchema: z.ZodObject<{
+    currency: z.ZodString;
+    totalCents: z.ZodNumber;
+    dueNowCents: z.ZodNumber;
+    laterPaymentAmountsCents: z.ZodArray<z.ZodNumber>;
+    paymentOption: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"upfront">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"deferred_manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"instalment_plan">;
+        plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"deposit_plus_one_remainder">;
+            depositAmountCents: z.ZodNumber;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+            remainderDueCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"deposit_plus_scheduled_instalments">;
+            depositAmountCents: z.ZodNumber;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+            instalmentCount: z.ZodNumber;
+            intervalCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"equal_scheduled_instalments">;
+            instalmentCount: z.ZodNumber;
+            intervalCount: z.ZodNumber;
+            intervalUnit: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+            }>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"flexible_balance">;
+        config: z.ZodObject<{
+            upfrontAmountCents: z.ZodNumber;
+            dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"relative_to_start_date">;
+                daysBeforeStart: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixed_calendar_date">;
+                dueAt: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            depositRefundability: z.ZodEnum<{
+                refundable: "refundable";
+                non_refundable: "non_refundable";
+            }>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">, z.ZodObject<{
+        kind: z.ZodLiteral<"not_required">;
+    }, z.core.$strict>]>;
+    promisedDiscountId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
 export {};

package/dist/_dts/core/src/branded.d.ts

@@ -139,7 +139,6 @@ export type DemoLifecycleAuditEventId = Brand<string, 'DemoLifecycleAuditEventId
 export type DemoRuntimeId = Brand<string, 'DemoRuntimeId'>;
 export type DemoCapability = Brand<string, 'DemoCapability'>;
 export type DemoPaymentFlowId = Brand<string, 'DemoPaymentFlowId'>;
-export type DemoClaimTtlHours = Brand<number, 'DemoClaimTtlHours'>;
 export type GiftingOfferId = Brand<string, 'GiftingOfferId'>;
 export type GiftingInstrumentId = Brand<string, 'GiftingInstrumentId'>;
 export type BookingRequirementId = Brand<string, 'BookingRequirementId'>;
@@ -278,7 +277,6 @@ export declare const unsafeAsDemoLifecycleAuditEventId: (id: string) => DemoLife
 export declare const unsafeAsDemoRuntimeId: (id: string) => DemoRuntimeId;
 export declare const unsafeAsDemoCapability: (value: string) => DemoCapability;
 export declare const unsafeAsDemoPaymentFlowId: (id: string) => DemoPaymentFlowId;
-export declare const unsafeAsDemoClaimTtlHours: (value: number) => DemoClaimTtlHours;
 export declare const unsafeAsGiftingOfferId: (id: string) => GiftingOfferId;
 export declare const unsafeAsGiftingInstrumentId: (id: string) => GiftingInstrumentId;
 export declare const unsafeAsBookingRequirementId: (id: string) => BookingRequirementId;

package/dist/_dts/core/src/demo-claim-access.d.ts

@@ -4,7 +4,7 @@ export type DemoClaimAccessInstance = Readonly<{
     status: DemoInstanceStatus;
 }>;
 export type DemoClaimAccessClaim = Readonly<{
-    status: DemoClaimStatus;
+    status: Exclude<DemoClaimStatus, 'preparing'>;
     expiresAt: string;
 }> | null;
 export declare function deriveDemoClaimAccessState(input: Readonly<{

package/dist/_dts/core/src/demo-claim-readiness.d.ts

@@ -0,0 +1,18 @@
+import type { DemoClaimId, DemoBlueprintVersionId, SiteId } from './branded';
+export type DemoClaimReadiness = Readonly<{
+    status: 'preparing';
+    claimId: DemoClaimId;
+    blueprintVersionId: DemoBlueprintVersionId;
+}> | Readonly<{
+    status: 'ready';
+    claimId: DemoClaimId;
+    blueprintVersionId: DemoBlueprintVersionId;
+    siteId: SiteId;
+    expiresAt: string;
+}> | Readonly<{
+    status: 'ended';
+    claimId: DemoClaimId;
+}> | Readonly<{
+    status: 'setup_failed';
+    claimId: DemoClaimId;
+}>;

package/dist/_dts/core/src/demo-lifecycle-status.d.ts

@@ -2,7 +2,7 @@ export declare const demoBlueprintStatusValues: readonly ["draft", "published",
 export type DemoBlueprintStatus = (typeof demoBlueprintStatusValues)[number];
 export declare const demoInstanceStatusValues: readonly ["warming", "available", "claimed", "expired", "showcase", "failed"];
 export type DemoInstanceStatus = (typeof demoInstanceStatusValues)[number];
-export declare const demoClaimStatusValues: readonly ["active", "expired", "released"];
+export declare const demoClaimStatusValues: readonly ["preparing", "active", "expired", "released"];
 export type DemoClaimStatus = (typeof demoClaimStatusValues)[number];
 export declare const demoBlueprintArtifactKindValues: readonly ["recipe"];
 export type DemoBlueprintArtifactKind = (typeof demoBlueprintArtifactKindValues)[number];

package/dist/_dts/core/src/demo-warm-pool-target.d.ts

@@ -1,5 +1,5 @@
 import { type Result } from './result';
-export declare const DEFAULT_DEMO_WARM_POOL_TARGET = 0;
+export declare const DEFAULT_DEMO_WARM_POOL_TARGET = 1;
 export declare const MAX_DEMO_WARM_POOL_TARGET = 20;
 export type DemoWarmPoolTargetError = Readonly<{
     kind: 'invalid_demo_warm_pool_target';

package/dist/_dts/core/src/index.d.ts

@@ -15,12 +15,14 @@ export * from './event-page-surface-subject';
 export * from './event-page-selection';
 export * from './public-event-booking-availability';
 export * from './money-input';
+export * from './ticket-quantity';
 export * from './booking-flexible-balance';
 export * from './booking-refunds';
 export * from './booking-instalments';
 export * from './booking-instalment-deposit';
 export * from './booking-live-payment-terms';
 export * from './booking-payment-options';
+export * from './appointment-booking-terms';
 export * from './booking-date-time';
 export * from './booking-consent';
 export * from './appointment-service-categories';
@@ -54,6 +56,7 @@ export * from './mailing-list-identifiers';
 export * from './mailing-list-setup';
 export * from './mailing-list-setup-parser';
 export * from './mailing-list-targeting';
+export * from './mailing-list-targeting-availability';
 export * from './mailing-list-runtime';
 export * from './mailing-list-targeting-parser';
 export * from './mailing-list-submission';
@@ -86,3 +89,4 @@ export * from './navigation-portal-labels';
 export * from './event-preset-vocabulary';
 export * from './event-catalogue';
 export * from './patch';
+export * from './demo-claim-readiness';

package/dist/_dts/core/src/mailing-list-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { BrevoListId, MailchimpAudienceId, MailchimpInterestId } from './mailing-list-identifiers';
 import { type Result } from './result';
-import type { MailingListGlobalForm, MailingListSetupRevision, NativeMailingListTopicId } from './mailing-list-setup';
+import type { MailingListGlobalForm, MailingListSetupRevision, NativeMailingListTopicId, NewsletterAudience } from './mailing-list-setup';
 export type MailingListRuntimeContext = Readonly<{
     tag: 'not_configured';
 }> | Readonly<{
@@ -12,7 +12,7 @@ export type MailingListRuntimeContext = Readonly<{
 }>;
 export type MailingListRuntimeProvider = Readonly<{
     provider: 'native';
-    defaultTopicId: NativeMailingListTopicId;
+    defaultAudience: NewsletterAudience;
     topics: readonly Readonly<{
         id: NativeMailingListTopicId;
         name: string;

package/dist/_dts/core/src/mailing-list-setup-parser.d.ts

@@ -1,5 +1,12 @@
-import type { ConfiguredMailingListProvider, MailingListGlobalForm, MailingListSetupRevision, MailingListSiteSetup } from './mailing-list-setup';
+import type { ConfiguredMailingListProvider, MailingListGlobalForm, MailingListSetupRevision, MailingListSiteSetup, NewsletterAudience } from './mailing-list-setup';
 import { type Result } from './result';
+import { z } from 'zod';
+export declare const newsletterAudienceSchema: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+    kind: "general";
+}> | Readonly<{
+    kind: "topic";
+    topicId: import("./mailing-list-setup").NativeMailingListTopicId;
+}>, unknown>>;
 export type MailingListSetupParseError = Readonly<{
     tag: 'invalid_mailing_list_setup';
     field: 'shape' | 'tag' | 'siteId' | 'revision' | 'form' | 'provider' | 'connectionId' | 'accountId' | 'defaultTargetId' | 'confirmation';
@@ -11,4 +18,5 @@ export type MailingListGlobalFormParseError = Readonly<{
 export declare function parseMailingListGlobalForm(value: unknown): Result<MailingListGlobalForm, MailingListGlobalFormParseError>;
 export declare function parseMailingListSiteSetup(value: unknown): Result<MailingListSiteSetup, MailingListSetupParseError>;
 export declare function parseConfiguredMailingListProvider(value: unknown): Result<ConfiguredMailingListProvider, MailingListSetupParseError>;
+export declare function parseNewsletterAudience(value: unknown): Result<NewsletterAudience, 'invalid_newsletter_audience'>;
 export declare function parseMailingListSetupRevision(value: unknown): MailingListSetupRevision | null;

package/dist/_dts/core/src/mailing-list-setup.d.ts

@@ -5,6 +5,14 @@ export type MailingListProvider = 'native' | 'mailchimp' | 'brevo';
 /** The name shown to people for each provider; the native one is the product brand. */
 export declare function mailingListProviderName(provider: MailingListProvider): string;
 export type NativeMailingListTopicId = NewsletterListId;
+/** An explicit subscription scope; absence of a topic never grants general consent. */
+export type NewsletterAudience = Readonly<{
+    kind: 'general';
+}> | Readonly<{
+    kind: 'topic';
+    topicId: NativeMailingListTopicId;
+}>;
+export declare function sameNewsletterAudience(left: NewsletterAudience, right: NewsletterAudience): boolean;
 export type MailingListSetupRevision = Brand<number, 'MailingListSetupRevision'>;
 export type MailingListProfileField = 'name' | 'first_name' | 'last_name' | 'company' | 'phone';
 export type MailingListGlobalFields = Readonly<{
@@ -48,7 +56,7 @@ export type BrevoConfirmation = Readonly<{
 }>;
 export type NativeMailingListSetup = Readonly<{
     provider: 'native';
-    defaultTopicId: NativeMailingListTopicId;
+    defaultAudience: NewsletterAudience;
     confirmation: ToggleConfirmation;
 }>;
 export type MailchimpMailingListSetup = Readonly<{

package/dist/_dts/core/src/mailing-list-submission.d.ts

@@ -185,7 +185,7 @@ export type MailingListPublicSignupResponse = Readonly<{
     reason: 'profile_rejected';
 }> | Readonly<{
     tag: 'unavailable';
-    reason: 'configuration_unavailable' | 'stale_configuration' | 'authentication_failed' | 'target_unavailable' | 'rate_limited' | 'temporarily_unavailable';
+    reason: 'confirmation_email_failed' | 'configuration_unavailable' | 'stale_configuration' | 'authentication_failed' | 'target_unavailable' | 'rate_limited' | 'temporarily_unavailable';
 }> | Readonly<{
     tag: 'uncertain';
     reason: 'deadline_exceeded' | 'network_interrupted';

package/dist/_dts/core/src/mailing-list-targeting-availability.d.ts

@@ -0,0 +1,68 @@
+import type { MailingListRuntimeContext, MailingListRuntimeProvider } from './mailing-list-runtime';
+import { type MailingListDefaultTargeting, type MailingListPlacementTargeting } from './mailing-list-targeting';
+type CustomTargeting = Exclude<MailingListPlacementTargeting, {
+    mode: 'default';
+}>;
+type Catalog<P extends MailingListRuntimeProvider['provider']> = Extract<MailingListRuntimeProvider, {
+    provider: P;
+}>;
+type Targeting<P extends CustomTargeting['provider']> = Extract<CustomTargeting, {
+    provider: P;
+}>;
+type Choice = Readonly<{
+    id: string | number;
+    name: string;
+}>;
+type MailchimpAudience = Catalog<'mailchimp'>['audiences'][number];
+/** Provider and placement stay correlated after the assessment has matched them. */
+export type MailingListMatchedTargeting = Readonly<{
+    provider: 'native';
+    catalog: Catalog<'native'>;
+    targeting: Targeting<'native'>;
+}> | Readonly<{
+    provider: 'brevo';
+    catalog: Catalog<'brevo'>;
+    targeting: Targeting<'brevo'>;
+}> | Readonly<{
+    provider: 'mailchimp';
+    catalog: Catalog<'mailchimp'>;
+    targeting: Targeting<'mailchimp'>;
+    audience: MailchimpAudience;
+}>;
+export type MailingListResolvedCustomTargeting = MailingListMatchedTargeting & Readonly<{
+    mode: 'custom';
+    choices: readonly Choice[];
+    selectedChoices: readonly Choice[];
+}>;
+export type MailingListResolvedTargeting = MailingListResolvedCustomTargeting | Readonly<{
+    mode: 'default';
+    provider: MailingListRuntimeProvider['provider'];
+    targeting: MailingListDefaultTargeting;
+    destination: Choice;
+}>;
+export type MailingListMissingAudienceTargeting = Readonly<{
+    mode: 'custom';
+    provider: 'mailchimp';
+    catalog: Catalog<'mailchimp'>;
+    targeting: Targeting<'mailchimp'>;
+}>;
+export type MailingListTargetingAvailability = Readonly<{
+    tag: 'available';
+    value: MailingListResolvedTargeting;
+}> | Readonly<{
+    tag: 'unavailable';
+    reason: 'setup_missing' | 'provider_mismatch' | 'default_missing';
+    targeting: MailingListPlacementTargeting;
+}> | Readonly<{
+    tag: 'unavailable';
+    reason: 'audience_missing';
+    value: MailingListMissingAudienceTargeting;
+}> | Readonly<{
+    tag: 'unavailable';
+    reason: 'choices_missing';
+    missingIds: readonly (string | number)[];
+    value: MailingListResolvedCustomTargeting;
+}>;
+export declare function resolveMailingListDefaultDestination(provider: MailingListRuntimeProvider): Choice | null;
+export declare function assessMailingListTargeting(context: MailingListRuntimeContext | undefined, targeting: MailingListPlacementTargeting): MailingListTargetingAvailability;
+export {};

package/dist/_dts/core/src/mailing-list-targeting.d.ts

@@ -5,10 +5,19 @@ import { type Result } from './result';
 export type MailingListDefaultTargeting = Readonly<{
     mode: 'default';
 }>;
+export type NativeMailingListAudience = Readonly<{
+    kind: 'general';
+}> | Readonly<{
+    kind: 'topics';
+    topicIds: ReadonlyNonEmptyArray<NativeMailingListTopicId>;
+}>;
+export declare const DEFAULT_MAILING_LIST_TARGETING: MailingListDefaultTargeting;
 export type NativeMailingListCustomTargeting = Readonly<{
     mode: 'custom';
     provider: 'native';
     selection: Readonly<{
+        tag: 'general';
+    }> | Readonly<{
         tag: 'fixed';
         topicIds: ReadonlyNonEmptyArray<NativeMailingListTopicId>;
     }> | Readonly<{
@@ -41,6 +50,7 @@ export type MailchimpMailingListCustomTargeting = Readonly<{
 }>;
 export type MailingListPlacementTargeting = MailingListDefaultTargeting | NativeMailingListCustomTargeting | BrevoMailingListCustomTargeting | MailchimpMailingListCustomTargeting;
 export declare function sameMailingListPlacementTargeting(left: MailingListPlacementTargeting, right: MailingListPlacementTargeting): boolean;
+export declare function mailingListTargetingChoiceIds(targeting: Exclude<MailingListPlacementTargeting, MailingListDefaultTargeting>): readonly (string | number)[];
 export type MailingListVisitorSelection = Readonly<{
     provider: 'native';
     topicIds: readonly NativeMailingListTopicId[];
@@ -53,7 +63,7 @@ export type MailingListVisitorSelection = Readonly<{
 }>;
 export type ResolvedMailingListTarget = Readonly<{
     provider: 'native';
-    topicIds: ReadonlyNonEmptyArray<NativeMailingListTopicId>;
+    audience: NativeMailingListAudience;
 }> | Readonly<{
     provider: 'brevo';
     listIds: ReadonlyNonEmptyArray<BrevoListId>;

package/dist/_dts/core/src/ticket-quantity.d.ts

@@ -0,0 +1,13 @@
+import type { Brand } from './branded';
+import { type Result } from './result';
+/** A whole number of booked places, at least one. */
+export type PositiveTicketQuantity = Brand<number, 'PositiveTicketQuantity'>;
+export declare function toPositiveTicketQuantity(value: number): Result<PositiveTicketQuantity, 'invalid_quantity'>;
+/**
+ * The places a booking holds: the sum of its ticket lines' quantities. The one
+ * derivation for selections, persisted lines and a booking outcome's lines;
+ * null when the total is not a positive whole number.
+ */
+export declare function deriveTotalTicketQuantity(lines: readonly Readonly<{
+    quantity: number;
+}>[]): PositiveTicketQuantity | null;