@riverbankcms/sdk 0.148.0 → 0.150.0

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useEventRegistrationWizard.d.ts

@@ -5,6 +5,7 @@ import { useWaitlistClaim } from '../../shared/useWaitlistClaim';
 import { useEventRegistrationStripeReturn } from './useEventRegistrationStripeReturn';
 import { useEventRegistrationSubmit } from './useEventRegistrationSubmit';
 import { useDiscountCodeUi } from './useDiscountCodeUi';
+import { useBookingNowIso } from '../../hooks/useBookingNowIso';
 export type EventRegistrationDetailsCompleteResult = Readonly<{
     ok: true;
     outcome: 'payment-step' | 'submitted';
@@ -30,9 +31,11 @@ export type EventRegistrationWizardDeps = Readonly<{
     useEventRegistrationStripeReturn: typeof useEventRegistrationStripeReturn;
     useEventRegistrationSubmit: typeof useEventRegistrationSubmit;
     useDiscountCodeUi: typeof useDiscountCodeUi;
+    useBookingNowIso: typeof useBookingNowIso;
 }>;
 export declare function useEventRegistrationWizard(options: UseEventRegistrationWizardOptions): {
     api: import("../../api").BoundBlockApiClient;
+    nowIso: string;
     anchorId: string;
     occurrenceContext: {
         id: string;
@@ -54,13 +57,16 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     preSelectedEvent: RegistrationEvent | null;
     hasPreSelectedContext: boolean;
     step: RegistrationStep;
-    setStep: (nextStep: RegistrationStep) => void;
+    setStep: (next: RegistrationStep) => void;
+    admission: import("./registrationCompletion").RegistrationAdmission;
+    ticketContinuation: import("./registrationCompletion").RegistrationTicketContinuation;
+    handleTicketsComplete: () => import("./event-registration.headless.contract").EventRegistrationFlowActionResult;
     selectedEvent: RegistrationEvent | null;
-    setSelectedEvent: import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>;
+    setSelectedEvent: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>>[0]) => void;
     ticketsCount: number;
-    setTicketsCount: (nextTicketsCount: number) => void;
+    setTicketsCount: (value: Parameters<(nextTicketsCount: number) => void>[0]) => void;
     selectedAttendanceMode: "in_person" | "online" | null;
-    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>;
+    setSelectedAttendanceMode: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>>[0]) => void;
     ticketSelections: Readonly<{
         pricingOptionId: string | null;
         quantity: number;
@@ -71,7 +77,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     }>[];
     setSelectedTicketLines: (lines: readonly EventTicketSelectionLine[]) => void;
     selectedSlidingAmountInput: string;
-    setSelectedSlidingAmountInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setSelectedSlidingAmountInput: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<string>>>[0]) => void;
     selectedSlidingAmount: number | null;
     selectedEventSlidingScale: Readonly<{
         minAmount: number;
@@ -96,10 +102,10 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     mailingListSignup: Readonly<{
         siteName: string;
     }> | null;
-    setFormData: import("react").Dispatch<import("react").SetStateAction<FormData>>;
+    setFormData: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<FormData>>>[0]) => void;
     errors: Partial<Record<keyof FormData, string>>;
     guests: Guest[];
-    setGuests: import("react").Dispatch<import("react").SetStateAction<Guest[]>>;
+    setGuests: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<Guest[]>>>[0]) => void;
     guestErrors: GuestErrors;
     guestSectionShake: boolean;
     handleGuestShakeEnd: () => void;
@@ -116,7 +122,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     handleLogout: () => void;
     paymentStepState: PaymentStepState;
     handlePaymentStepStateChange: (state: PaymentStepState) => void;
-    handlePaymentSelectionChange: (selection: PaymentSelection) => void;
+    handlePaymentSelectionChange: (value: Parameters<(selection: PaymentSelection) => void>[0]) => void;
     paymentSelection: PaymentSelection;
     isMembershipFastTrack: boolean;
     waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
@@ -140,7 +146,7 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     hasMembershipEligibility: boolean;
     requireGuestDetails: boolean;
     discountCode: string;
-    setDiscountCode: (code: string) => void;
+    setDiscountCode: (value: string) => void;
     discountUiOpen: boolean;
     setDiscountUiOpen: (isOpen: boolean) => void;
     discountsAvailable: boolean;
@@ -149,22 +155,53 @@ export declare function useEventRegistrationWizard(options: UseEventRegistration
     discountsAvailableLoading: boolean;
     discountContext: import("../../api").DiscountContext | null;
     shouldShowDiscountToggle: boolean;
-    verification: import("./useEventRegistrationStripeReturn").EventRegistrationStripeReturnResult;
+    verification: {
+        retry: () => void;
+        retryReturn: () => void;
+        status: "idle" | "polling" | "completed" | "failed" | "timeout";
+        result: import("../../api").EventCheckoutReturnResponse | null;
+        error: Error | null;
+    };
+    paymentController: {
+        backToBooking: () => Promise<void>;
+        continuePayment: () => void;
+        returnToPayment: () => void;
+        returnToBooking: () => void;
+        check: () => void;
+        retryPaymentLoad: () => void;
+        verification: {
+            retry: () => void;
+            retryReturn: () => void;
+            status: "idle" | "polling" | "completed" | "failed" | "timeout";
+            result: import("../../api").EventCheckoutReturnResponse | null;
+            error: Error | null;
+        };
+        state: import("./types").EventPaymentState;
+        recovery: import("./types").PaymentStatusRecoveryState | null;
+        showRecovery: (next: import("./types").PaymentStatusRecoveryState | null) => void;
+        restoreMailingListNote: (value: import("./types").PaymentStatusRecoveryState["mailingListSignupNote"]) => void;
+        openPayment: (checkout: import("../../api/types").EventEmbeddedCheckout, subject: import("../../api/types").EventRegistrationPaymentSubject, mailingListSignupNote?: import("./types").PaymentStatusRecoveryState["mailingListSignupNote"]) => void;
+        verify: (request: import("../../api").EventCheckoutReturnRequest, resumePayment?: boolean) => void;
+    };
     paymentStatusRecovery: import("./types").PaymentStatusRecoveryState | null;
     handleCheckPaymentStatus: () => void;
     handleContinueExistingPayment: () => void;
     handleReturnToPayment: () => void;
     handleReturnToBooking: () => void;
+    recoveryMessage: string | null;
+    checkingNextStep: boolean;
+    handleRecoveryEmail: () => Promise<import("./event-registration.headless.contract").EventRegistrationFlowActionResult>;
     handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: import("./useEventRegistrationSubmit").EventRegistrationSubmit;
-    handleEventSelect: (event: RegistrationEvent) => void;
+    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string | undefined, membershipId?: string | undefined, selection?: PaymentSelection | undefined) => ReturnType<import("./useEventRegistrationSubmit").EventRegistrationSubmit>;
+    handleEventSelect: (value: Parameters<(event: RegistrationEvent) => void>[0]) => void;
     handleRetry: () => void;
 };
 export declare function useEventRegistrationWizardWithDeps(options: UseEventRegistrationWizardOptions, deps: EventRegistrationWizardDeps): {
     api: import("../../api").BoundBlockApiClient;
+    nowIso: string;
     anchorId: string;
     occurrenceContext: {
         id: string;
@@ -186,13 +223,16 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     preSelectedEvent: RegistrationEvent | null;
     hasPreSelectedContext: boolean;
     step: RegistrationStep;
-    setStep: (nextStep: RegistrationStep) => void;
+    setStep: (next: RegistrationStep) => void;
+    admission: import("./registrationCompletion").RegistrationAdmission;
+    ticketContinuation: import("./registrationCompletion").RegistrationTicketContinuation;
+    handleTicketsComplete: () => import("./event-registration.headless.contract").EventRegistrationFlowActionResult;
     selectedEvent: RegistrationEvent | null;
-    setSelectedEvent: import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>;
+    setSelectedEvent: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>>[0]) => void;
     ticketsCount: number;
-    setTicketsCount: (nextTicketsCount: number) => void;
+    setTicketsCount: (value: Parameters<(nextTicketsCount: number) => void>[0]) => void;
     selectedAttendanceMode: "in_person" | "online" | null;
-    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>;
+    setSelectedAttendanceMode: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>>[0]) => void;
     ticketSelections: Readonly<{
         pricingOptionId: string | null;
         quantity: number;
@@ -203,7 +243,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     }>[];
     setSelectedTicketLines: (lines: readonly EventTicketSelectionLine[]) => void;
     selectedSlidingAmountInput: string;
-    setSelectedSlidingAmountInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setSelectedSlidingAmountInput: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<string>>>[0]) => void;
     selectedSlidingAmount: number | null;
     selectedEventSlidingScale: Readonly<{
         minAmount: number;
@@ -228,10 +268,10 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     mailingListSignup: Readonly<{
         siteName: string;
     }> | null;
-    setFormData: import("react").Dispatch<import("react").SetStateAction<FormData>>;
+    setFormData: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<FormData>>>[0]) => void;
     errors: Partial<Record<keyof FormData, string>>;
     guests: Guest[];
-    setGuests: import("react").Dispatch<import("react").SetStateAction<Guest[]>>;
+    setGuests: (value: Parameters<import("react").Dispatch<import("react").SetStateAction<Guest[]>>>[0]) => void;
     guestErrors: GuestErrors;
     guestSectionShake: boolean;
     handleGuestShakeEnd: () => void;
@@ -248,7 +288,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     handleLogout: () => void;
     paymentStepState: PaymentStepState;
     handlePaymentStepStateChange: (state: PaymentStepState) => void;
-    handlePaymentSelectionChange: (selection: PaymentSelection) => void;
+    handlePaymentSelectionChange: (value: Parameters<(selection: PaymentSelection) => void>[0]) => void;
     paymentSelection: PaymentSelection;
     isMembershipFastTrack: boolean;
     waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
@@ -272,7 +312,7 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     hasMembershipEligibility: boolean;
     requireGuestDetails: boolean;
     discountCode: string;
-    setDiscountCode: (code: string) => void;
+    setDiscountCode: (value: string) => void;
     discountUiOpen: boolean;
     setDiscountUiOpen: (isOpen: boolean) => void;
     discountsAvailable: boolean;
@@ -281,18 +321,48 @@ export declare function useEventRegistrationWizardWithDeps(options: UseEventRegi
     discountsAvailableLoading: boolean;
     discountContext: import("../../api").DiscountContext | null;
     shouldShowDiscountToggle: boolean;
-    verification: import("./useEventRegistrationStripeReturn").EventRegistrationStripeReturnResult;
+    verification: {
+        retry: () => void;
+        retryReturn: () => void;
+        status: "idle" | "polling" | "completed" | "failed" | "timeout";
+        result: import("../../api").EventCheckoutReturnResponse | null;
+        error: Error | null;
+    };
+    paymentController: {
+        backToBooking: () => Promise<void>;
+        continuePayment: () => void;
+        returnToPayment: () => void;
+        returnToBooking: () => void;
+        check: () => void;
+        retryPaymentLoad: () => void;
+        verification: {
+            retry: () => void;
+            retryReturn: () => void;
+            status: "idle" | "polling" | "completed" | "failed" | "timeout";
+            result: import("../../api").EventCheckoutReturnResponse | null;
+            error: Error | null;
+        };
+        state: import("./types").EventPaymentState;
+        recovery: import("./types").PaymentStatusRecoveryState | null;
+        showRecovery: (next: import("./types").PaymentStatusRecoveryState | null) => void;
+        restoreMailingListNote: (value: import("./types").PaymentStatusRecoveryState["mailingListSignupNote"]) => void;
+        openPayment: (checkout: import("../../api/types").EventEmbeddedCheckout, subject: import("../../api/types").EventRegistrationPaymentSubject, mailingListSignupNote?: import("./types").PaymentStatusRecoveryState["mailingListSignupNote"]) => void;
+        verify: (request: import("../../api").EventCheckoutReturnRequest, resumePayment?: boolean) => void;
+    };
     paymentStatusRecovery: import("./types").PaymentStatusRecoveryState | null;
     handleCheckPaymentStatus: () => void;
     handleContinueExistingPayment: () => void;
     handleReturnToPayment: () => void;
     handleReturnToBooking: () => void;
+    recoveryMessage: string | null;
+    checkingNextStep: boolean;
+    handleRecoveryEmail: () => Promise<import("./event-registration.headless.contract").EventRegistrationFlowActionResult>;
     handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
     handlePaymentSelect: () => Promise<void>;
     handleUseCardInsteadOfPass: () => void;
     handleBookForSomeoneElse: () => void;
-    handleSubmit: import("./useEventRegistrationSubmit").EventRegistrationSubmit;
-    handleEventSelect: (event: RegistrationEvent) => void;
+    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string | undefined, membershipId?: string | undefined, selection?: PaymentSelection | undefined) => ReturnType<import("./useEventRegistrationSubmit").EventRegistrationSubmit>;
+    handleEventSelect: (value: Parameters<(event: RegistrationEvent) => void>[0]) => void;
     handleRetry: () => void;
 };
 export type UseEventRegistrationWizardResult = ReturnType<typeof useEventRegistrationWizard>;

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useGuestRegistrationRecovery.d.ts

@@ -0,0 +1,30 @@
+import type { EventRegistrationNextStepResponse } from '../../api/types';
+import type { BoundBlockApiClient } from '../../api';
+import type { FormData, RegistrationStep, EventTicketSelectionLine, RegistrationAttendanceMode } from './types';
+import type { EventRegistrationFlowActionResult } from './event-registration.headless.contract';
+import { type RegistrationAdmission } from './registrationCompletion';
+import { type resolveRegistrationTarget } from './registrationDerivations';
+import type { PortalAuthState } from './hooks';
+type Input = Readonly<{
+    api: Pick<BoundBlockApiClient, 'checkRegistrationNextStep'>;
+    formData: FormData;
+    onRecoveryChecked: (outcome: EventRegistrationNextStepResponse) => void;
+    registrationTarget: ReturnType<typeof resolveRegistrationTarget>;
+    selectedAttendanceMode: RegistrationAttendanceMode | null;
+    ticketSelections: readonly EventTicketSelectionLine[];
+    selectedSlidingAmount: number | null;
+    altchaSolution: string | null;
+    step: RegistrationStep;
+    portalAuthState: PortalAuthState;
+    admission: RegistrationAdmission;
+    setErrors: (errors: Partial<Record<keyof FormData, string>>) => void;
+}>;
+/** Guest email is navigation permission only. Discard checks when the visitor
+ * changes identity or selection before the response arrives. */
+export declare function useGuestRegistrationRecovery(input: Input): {
+    checkingNextStep: boolean;
+    recoveryMessage: string | null;
+    checkDetailsNextStep: () => Promise<EventRegistrationNextStepResponse>;
+    handleRecoveryEmail: () => Promise<EventRegistrationFlowActionResult>;
+};
+export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/usePaymentStatusRecovery.d.ts

@@ -1,23 +1,35 @@
 import { type Dispatch, type SetStateAction } from 'react';
 import type { BlockApiClient } from '../../api/client';
-import type { EventRegistrationStatusReference } from '../../api/types';
-import type { PaymentStatusRecoveryState, RegistrationResult, RegistrationStep } from './types';
-type PaymentStatusSetters = Readonly<{
-    setPendingRegistrationReference: Dispatch<SetStateAction<EventRegistrationStatusReference | null>>;
+import type { EventCheckoutReturnRequest, EventCheckoutReturnResponse, EventEmbeddedCheckout, EventRegistrationPaymentSubject } from '../../api/types';
+import type { EventPaymentState, PaymentStatusRecoveryState, RegistrationResult, RegistrationStep } from './types';
+type Options = Readonly<{
+    api: BlockApiClient;
+    beginNewSubmission: () => void;
     setRegistrationResult: Dispatch<SetStateAction<RegistrationResult | null>>;
     setOptionsRefreshKey: Dispatch<SetStateAction<number>>;
     setStep: (step: RegistrationStep) => void;
+    /** Whether this page still holds the booker's details; a restored page after a reload does not. */
+    detailsInPage: () => boolean;
 }>;
-type UsePaymentStatusRecoveryOptions = PaymentStatusSetters & Readonly<{
-    api: BlockApiClient;
-    beginNewSubmission: () => void;
-}>;
-export declare function usePaymentStatusRecovery(options: UsePaymentStatusRecoveryOptions): {
-    recovery: PaymentStatusRecoveryState | null;
-    showRecovery: (next: PaymentStatusRecoveryState | null) => void;
-    check: () => void;
+export declare function usePaymentStatusRecovery(options: Options): {
+    backToBooking: () => Promise<void>;
     continuePayment: () => void;
     returnToPayment: () => void;
     returnToBooking: () => void;
+    check: () => void;
+    retryPaymentLoad: () => void;
+    verification: {
+        retry: () => void;
+        retryReturn: () => void;
+        status: "idle" | "polling" | "completed" | "failed" | "timeout";
+        result: EventCheckoutReturnResponse | null;
+        error: Error | null;
+    };
+    state: EventPaymentState;
+    recovery: PaymentStatusRecoveryState | null;
+    showRecovery: (next: PaymentStatusRecoveryState | null) => void;
+    restoreMailingListNote: (value: PaymentStatusRecoveryState["mailingListSignupNote"]) => void;
+    openPayment: (checkout: EventEmbeddedCheckout, subject: EventRegistrationPaymentSubject, mailingListSignupNote?: PaymentStatusRecoveryState["mailingListSignupNote"]) => void;
+    verify: (request: EventCheckoutReturnRequest, resumePayment?: boolean) => void;
 };
 export {};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/useRegistrationAdmission.d.ts

@@ -0,0 +1,18 @@
+import { type Dispatch } from 'react';
+import { resolveRegistrationAdmission } from './registrationCompletion';
+import type { RegistrationFlowAction } from './registrationStateMachine';
+import type { EventRegistrationFlowActionResult } from './event-registration.headless.contract';
+/** Owns admission and its navigation commands; renderers receive decisions. */
+export declare function useRegistrationAdmission(input: Parameters<typeof resolveRegistrationAdmission>[0] & Readonly<{
+    existingRegistrationLoading: boolean;
+    ticketSelectionRequired: boolean;
+    hasValidTicketSelection: boolean;
+    dispatchFlow: Dispatch<RegistrationFlowAction>;
+}>): {
+    admission: import("./registrationCompletion").RegistrationAdmission;
+    ticketContinuation: import("./registrationCompletion").RegistrationTicketContinuation;
+    handleTicketsComplete: () => EventRegistrationFlowActionResult;
+    onRecoveryChecked: (outcome: Extract<RegistrationFlowAction, {
+        type: "recovery-checked";
+    }>["outcome"]) => void;
+};

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration/wizardSteps.d.ts

@@ -3,6 +3,11 @@ import type { RegistrationStep } from './types';
  * Steps that are part of the main wizard and should show the step indicator
  */
 export declare const WIZARD_STEPS: RegistrationStep[];
+/** Recovery uses the form surface without adding a progress step. */
+export declare function getRegistrationStepPresentation(step: RegistrationStep, progressSteps: readonly RegistrationStep[]): Readonly<{
+    isWizardStep: boolean;
+    totalSteps: number;
+}>;
 /**
  * Determine which wizard steps to show based on context and payment requirements.
  *
@@ -10,7 +15,7 @@ export declare const WIZARD_STEPS: RegistrationStep[];
  * @param needsPaymentStep - Whether user must complete payment method selection
  * @returns Array of wizard steps to display
  */
-export declare function getWizardStepsForContext(hasPreSelectedContext: boolean, needsPaymentStep: boolean): readonly RegistrationStep[];
+export declare function getWizardStepsForContext(hasPreSelectedContext: boolean, needsPaymentStep: boolean, paymentActive?: boolean): readonly RegistrationStep[];
 /**
  * Map wizard step to step number based on the active wizard steps
  */

package/dist/_dts/blocks/src/system/runtime/nodes/event-registration.interactive.d.ts

@@ -9,7 +9,7 @@ import { type EventRegistrationPageSurfaceSubject } from './event-registration/e
 import { type InteractiveIslandProps } from '../../../contracts/islands';
 import { type EventRegistrationEventSource } from './event-registration/eventSourceRecovery';
 export declare const EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS: readonly ["Date", "Tickets", "Details"];
-declare const EVENT_REGISTRATION_SHELL_STEP_LABELS: readonly ["Event", "Date", "Tickets", "Details", "Payment"];
+declare const EVENT_REGISTRATION_SHELL_STEP_LABELS: readonly ["Event", "Date", "Tickets", "Details", "Payment options", "Payment"];
 export type EventRegistrationGenericShellStepLabels = typeof EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS;
 type EventRegistrationShellStepLabel = (typeof EVENT_REGISTRATION_SHELL_STEP_LABELS)[number];
 export type EventRegistrationSourceProps = Readonly<{

package/dist/_dts/blocks/src/system/runtime/nodes/events/shared/eventCollectionContract.d.ts

@@ -549,13 +549,13 @@ export declare const eventCollectionSourceSchemaShape: {
         siteTimeZone: z.ZodOptional<z.ZodString>;
         pricing: z.ZodType<import("../../../../../../../core/src/index").PublicEventPricing, unknown, z.core.$ZodTypeInternals<import("../../../../../../../core/src/index").PublicEventPricing, unknown>>;
         paymentTerms: z.ZodObject<{
-            allowedOptions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"upfront">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"deferred_manual">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"instalment_plan">;
-                plan: z.ZodUnion<readonly [z.ZodObject<{
+                plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"deposit_plus_one_remainder">;
                     depositAmountCents: z.ZodNumber;
                     depositRefundability: z.ZodEnum<{
@@ -591,24 +591,24 @@ export declare const eventCollectionSourceSchemaShape: {
                         week: "week";
                         month: "month";
                     }>;
-                }, z.core.$strip>]>;
+                }, z.core.$strip>], "kind">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"flexible_balance">;
                 config: z.ZodObject<{
                     upfrontAmountCents: z.ZodNumber;
-                    dueDateRule: z.ZodUnion<readonly [z.ZodObject<{
+                    dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
                         kind: z.ZodLiteral<"relative_to_start_date">;
                         daysBeforeStart: z.ZodNumber;
                     }, z.core.$strip>, z.ZodObject<{
                         kind: z.ZodLiteral<"fixed_calendar_date">;
                         dueAt: z.ZodString;
-                    }, z.core.$strip>]>;
+                    }, z.core.$strip>], "kind">;
                     depositRefundability: z.ZodEnum<{
                         refundable: "refundable";
                         non_refundable: "non_refundable";
                     }>;
                 }, z.core.$strip>;
-            }, z.core.$strip>]>>;
+            }, z.core.$strip>], "kind">>;
         }, z.core.$strip>;
         cancellationPolicy: z.ZodObject<{
             refunds: z.ZodObject<{
@@ -1038,13 +1038,13 @@ export declare const eventCollectionSourceSchemaShape: {
         siteTimeZone: z.ZodOptional<z.ZodString>;
         pricing: z.ZodType<import("../../../../../../../core/src/index").PublicEventPricing, unknown, z.core.$ZodTypeInternals<import("../../../../../../../core/src/index").PublicEventPricing, unknown>>;
         paymentTerms: z.ZodObject<{
-            allowedOptions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"upfront">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"deferred_manual">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"instalment_plan">;
-                plan: z.ZodUnion<readonly [z.ZodObject<{
+                plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"deposit_plus_one_remainder">;
                     depositAmountCents: z.ZodNumber;
                     depositRefundability: z.ZodEnum<{
@@ -1080,24 +1080,24 @@ export declare const eventCollectionSourceSchemaShape: {
                         week: "week";
                         month: "month";
                     }>;
-                }, z.core.$strip>]>;
+                }, z.core.$strip>], "kind">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"flexible_balance">;
                 config: z.ZodObject<{
                     upfrontAmountCents: z.ZodNumber;
-                    dueDateRule: z.ZodUnion<readonly [z.ZodObject<{
+                    dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
                         kind: z.ZodLiteral<"relative_to_start_date">;
                         daysBeforeStart: z.ZodNumber;
                     }, z.core.$strip>, z.ZodObject<{
                         kind: z.ZodLiteral<"fixed_calendar_date">;
                         dueAt: z.ZodString;
-                    }, z.core.$strip>]>;
+                    }, z.core.$strip>], "kind">;
                     depositRefundability: z.ZodEnum<{
                         refundable: "refundable";
                         non_refundable: "non_refundable";
                     }>;
                 }, z.core.$strip>;
-            }, z.core.$strip>]>>;
+            }, z.core.$strip>], "kind">>;
         }, z.core.$strip>;
         cancellationPolicy: z.ZodObject<{
             refunds: z.ZodObject<{
@@ -1588,13 +1588,13 @@ export declare const eventCollectionDisplaySchemaShape: {
         siteTimeZone: z.ZodOptional<z.ZodString>;
         pricing: z.ZodType<import("../../../../../../../core/src/index").PublicEventPricing, unknown, z.core.$ZodTypeInternals<import("../../../../../../../core/src/index").PublicEventPricing, unknown>>;
         paymentTerms: z.ZodObject<{
-            allowedOptions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"upfront">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"deferred_manual">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"instalment_plan">;
-                plan: z.ZodUnion<readonly [z.ZodObject<{
+                plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"deposit_plus_one_remainder">;
                     depositAmountCents: z.ZodNumber;
                     depositRefundability: z.ZodEnum<{
@@ -1630,24 +1630,24 @@ export declare const eventCollectionDisplaySchemaShape: {
                         week: "week";
                         month: "month";
                     }>;
-                }, z.core.$strip>]>;
+                }, z.core.$strip>], "kind">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"flexible_balance">;
                 config: z.ZodObject<{
                     upfrontAmountCents: z.ZodNumber;
-                    dueDateRule: z.ZodUnion<readonly [z.ZodObject<{
+                    dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
                         kind: z.ZodLiteral<"relative_to_start_date">;
                         daysBeforeStart: z.ZodNumber;
                     }, z.core.$strip>, z.ZodObject<{
                         kind: z.ZodLiteral<"fixed_calendar_date">;
                         dueAt: z.ZodString;
-                    }, z.core.$strip>]>;
+                    }, z.core.$strip>], "kind">;
                     depositRefundability: z.ZodEnum<{
                         refundable: "refundable";
                         non_refundable: "non_refundable";
                     }>;
                 }, z.core.$strip>;
-            }, z.core.$strip>]>>;
+            }, z.core.$strip>], "kind">>;
         }, z.core.$strip>;
         cancellationPolicy: z.ZodObject<{
             refunds: z.ZodObject<{
@@ -2077,13 +2077,13 @@ export declare const eventCollectionDisplaySchemaShape: {
         siteTimeZone: z.ZodOptional<z.ZodString>;
         pricing: z.ZodType<import("../../../../../../../core/src/index").PublicEventPricing, unknown, z.core.$ZodTypeInternals<import("../../../../../../../core/src/index").PublicEventPricing, unknown>>;
         paymentTerms: z.ZodObject<{
-            allowedOptions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            allowedOptions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"upfront">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"deferred_manual">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"instalment_plan">;
-                plan: z.ZodUnion<readonly [z.ZodObject<{
+                plan: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"deposit_plus_one_remainder">;
                     depositAmountCents: z.ZodNumber;
                     depositRefundability: z.ZodEnum<{
@@ -2119,24 +2119,24 @@ export declare const eventCollectionDisplaySchemaShape: {
                         week: "week";
                         month: "month";
                     }>;
-                }, z.core.$strip>]>;
+                }, z.core.$strip>], "kind">;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"flexible_balance">;
                 config: z.ZodObject<{
                     upfrontAmountCents: z.ZodNumber;
-                    dueDateRule: z.ZodUnion<readonly [z.ZodObject<{
+                    dueDateRule: z.ZodDiscriminatedUnion<[z.ZodObject<{
                         kind: z.ZodLiteral<"relative_to_start_date">;
                         daysBeforeStart: z.ZodNumber;
                     }, z.core.$strip>, z.ZodObject<{
                         kind: z.ZodLiteral<"fixed_calendar_date">;
                         dueAt: z.ZodString;
-                    }, z.core.$strip>]>;
+                    }, z.core.$strip>], "kind">;
                     depositRefundability: z.ZodEnum<{
                         refundable: "refundable";
                         non_refundable: "non_refundable";
                     }>;
                 }, z.core.$strip>;
-            }, z.core.$strip>]>>;
+            }, z.core.$strip>], "kind">>;
         }, z.core.$strip>;
         cancellationPolicy: z.ZodObject<{
             refunds: z.ZodObject<{