@riverbankcms/sdk 0.91.0 → 0.92.0

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.interactive.d.ts

@@ -152,6 +152,14 @@ export declare const bookingFormBlockRuntime: Readonly<{
                 title: string;
                 description?: string;
                 durationMinutes?: number;
+                pricing?: Readonly<{
+                    pricingStrategy: "free" | "single" | "tiered" | "sliding_scale";
+                    currency: string;
+                    singlePriceAmount?: number | null;
+                    slidingMinAmount?: number | null;
+                    slidingMaxAmount?: number | null;
+                    slidingSuggestedAmount?: number | null;
+                }>;
                 priceAmount?: number | null;
                 priceCurrency?: string | null;
                 paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;
@@ -348,6 +356,14 @@ export declare const bookingFormBlockRuntime: Readonly<{
                         title: string;
                         description?: string;
                         durationMinutes?: number;
+                        pricing?: Readonly<{
+                            pricingStrategy: "free" | "single" | "tiered" | "sliding_scale";
+                            currency: string;
+                            singlePriceAmount?: number | null;
+                            slidingMinAmount?: number | null;
+                            slidingMaxAmount?: number | null;
+                            slidingSuggestedAmount?: number | null;
+                        }>;
                         priceAmount?: number | null;
                         priceCurrency?: string | null;
                         paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;
@@ -424,6 +440,14 @@ export declare const bookingFormBlockRuntime: Readonly<{
                         title: string;
                         description?: string;
                         durationMinutes?: number;
+                        pricing?: Readonly<{
+                            pricingStrategy: "free" | "single" | "tiered" | "sliding_scale";
+                            currency: string;
+                            singlePriceAmount?: number | null;
+                            slidingMinAmount?: number | null;
+                            slidingMaxAmount?: number | null;
+                            slidingSuggestedAmount?: number | null;
+                        }>;
                         priceAmount?: number | null;
                         priceCurrency?: string | null;
                         paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;
@@ -512,6 +536,14 @@ export declare const bookingFormInteractiveIslandPropsCodec: Readonly<{
                     title: string;
                     description?: string;
                     durationMinutes?: number;
+                    pricing?: Readonly<{
+                        pricingStrategy: "free" | "single" | "tiered" | "sliding_scale";
+                        currency: string;
+                        singlePriceAmount?: number | null;
+                        slidingMinAmount?: number | null;
+                        slidingMaxAmount?: number | null;
+                        slidingSuggestedAmount?: number | null;
+                    }>;
                     priceAmount?: number | null;
                     priceCurrency?: string | null;
                     paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;
@@ -597,6 +629,14 @@ export declare const bookingFormInteractiveIslandPropsCodec: Readonly<{
                     title: string;
                     description?: string;
                     durationMinutes?: number;
+                    pricing?: Readonly<{
+                        pricingStrategy: "free" | "single" | "tiered" | "sliding_scale";
+                        currency: string;
+                        singlePriceAmount?: number | null;
+                        slidingMinAmount?: number | null;
+                        slidingMaxAmount?: number | null;
+                        slidingSuggestedAmount?: number | null;
+                    }>;
                     priceAmount?: number | null;
                     priceCurrency?: string | null;
                     paymentTerms?: import("../../blocks/shared/bookingPaymentTerms").BlockBookingPaymentTerms;

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.reserved-fields.d.ts

@@ -1,5 +1,5 @@
 export declare const APPOINTMENT_BOOKING_BLOCK_ID: "block.appointment-booking";
-export declare const BOOKING_FORM_DATA_RESERVED_KEY_VALUES: readonly ["serviceId", "resourceId", "selectedDate", "selectedSlot", "discountCode", "selectedCollectionOptionKind", "selectedAppointmentPackageId"];
+export declare const BOOKING_FORM_DATA_RESERVED_KEY_VALUES: readonly ["serviceId", "resourceId", "selectedDate", "selectedSlot", "discountCode", "selectedSlidingAmountInput", "selectedCollectionOptionKind", "selectedAppointmentPackageId"];
 export type BookingFormDataReservedKey = (typeof BOOKING_FORM_DATA_RESERVED_KEY_VALUES)[number];
 export type BookingReservedFieldCollision = Readonly<{
     fieldId: BookingFormDataReservedKey;

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.state.d.ts

@@ -61,12 +61,21 @@ type BlockBookingPaymentTermsAvailability = Readonly<{
     paymentTerms: BlockBookingPaymentTerms;
     reason: "online_payment_configured_before_launch";
 }>;
+export type BookingFormServicePricing = Readonly<{
+    pricingStrategy: "free" | "single" | "tiered" | "sliding_scale";
+    currency: string;
+    singlePriceAmount?: number | null;
+    slidingMinAmount?: number | null;
+    slidingMaxAmount?: number | null;
+    slidingSuggestedAmount?: number | null;
+}>;
 export type BookingFormService = Readonly<{
     id: string;
     siteId: string;
     title: string;
     description?: string;
     durationMinutes?: number;
+    pricing?: BookingFormServicePricing;
     priceAmount?: number | null;
     priceCurrency?: string | null;
     paymentTerms?: BlockBookingPaymentTerms;
@@ -85,6 +94,7 @@ export type BookingFormData<TCustomFieldId extends string = never> = Readonly<{
     selectedDate?: string;
     selectedSlot?: string;
     discountCode?: string;
+    selectedSlidingAmountInput?: string;
     selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
     selectedAppointmentPackageId?: string;
 }> & BookingCustomFieldData<TCustomFieldId>;
@@ -101,6 +111,7 @@ type BookingSubmissionCommon = Readonly<{
 export type BookingSubmissionData = (BookingSubmissionCommon & Readonly<{
     kind: "standard";
     discountCode?: string;
+    selectedSlidingAmount?: number;
     selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
     altchaSolution?: string | null;
     successUrl?: string;
@@ -111,6 +122,12 @@ export type BookingSubmissionData = (BookingSubmissionCommon & Readonly<{
 }>);
 export type BookingPaymentStepMode = "hidden" | "disclosure_only" | "choice_required" | "unsupported";
 type BookingPaymentSelectionMode = "implicit_upfront" | "implicit_deferred_manual" | "implicit_instalment_plan" | "implicit_flexible_balance" | "choice_required" | "pending_stripe_setup" | "unsupported";
+export type BookingServiceSlidingScale = Readonly<{
+    minAmount: number;
+    maxAmount: number;
+    suggestedAmount: number | null;
+    currency: string;
+}>;
 export type BookingPaymentStepResolution = Readonly<{
     mode: BookingPaymentStepMode;
     service: BookingFormService | null;
@@ -169,6 +186,14 @@ export type BookingSubmissionPreparationError = Readonly<{
     tag: "payment-option-required";
     serviceId: string;
     serviceTitle: string;
+}> | Readonly<{
+    tag: "sliding-amount-required";
+    serviceId: string;
+    serviceTitle: string;
+}> | Readonly<{
+    tag: "sliding-amount-out-of-range";
+    serviceId: string;
+    serviceTitle: string;
 }> | Readonly<{
     tag: "payment-option-unsupported";
     serviceId: string;
@@ -206,6 +231,10 @@ export declare function resolveBookingSiteId(siteId: string | undefined, form: B
 export declare function normalizeBookingFormConfig(form: unknown): BookingFormConfig | null;
 export declare function normalizeBookingServices(services: unknown): readonly BookingFormService[];
 export declare function toSelectedCollectionOptionKind(value: unknown): BookingSelectedCollectionOptionKind | undefined;
+export declare function getBookingServiceSlidingScale(service: BookingFormService | null | undefined): BookingServiceSlidingScale | null;
+export declare function parseBookingCurrencyInputToCents(value: string | undefined): number | null;
+export declare function formatBookingCentsAsCurrencyInput(amount: number): string;
+export declare function isBookingServiceSlidingAmountInRange(slidingScale: BookingServiceSlidingScale, selectedAmount: number | null): selectedAmount is number;
 export declare function getBookingServicePaymentSelectionMode(service: BookingFormService | undefined): BookingPaymentSelectionMode;
 export declare function resolveDefaultBookingServiceId(formConfig: BookingFormConfig | null | undefined, services: readonly BookingFormService[]): string | null;
 export declare function resolveBookingSelectedService(input: Readonly<{

package/dist/_dts/blocks/src/system/runtime/nodes/booking-runtime-sources.d.ts

@@ -91,6 +91,7 @@ export type AppointmentBookingServiceSourceInput = Readonly<{
     title: string;
     description?: string | null;
     durationMinutes?: number;
+    pricing?: BookingFormService["pricing"];
     priceAmount?: number | null;
     priceCurrency?: string | null;
     paymentTerms?: BookingFormService["paymentTerms"];

package/dist/_dts/blocks/src/system/runtime/nodes/course-registration/components.d.ts

@@ -27,6 +27,12 @@ interface CoursePricingSelectorProps {
     onSelect: (pricingOptionId: string) => void;
 }
 export declare function CoursePricingSelector({ pricing, selectedPricingOptionId, onSelect, }: CoursePricingSelectorProps): React.JSX.Element | null;
+interface CourseSlidingScaleInputProps {
+    pricing: ResolvedCoursePricingState;
+    value: string;
+    onChange: (value: string) => void;
+}
+export declare function CourseSlidingScaleInput({ pricing, value, onChange, }: CourseSlidingScaleInputProps): React.JSX.Element | null;
 interface EnrollmentFormProps {
     formData: FormData;
     errors: Partial<Record<keyof FormData, string>>;

package/dist/_dts/blocks/src/system/runtime/nodes/course-registration/useCourseRegistrationWizard.d.ts

@@ -10,12 +10,20 @@ export declare function useCourseRegistrationWizard(props: CourseRegistrationCli
     selectedCourse: PublicCourse | null;
     selectedPricingOptionId: string | null;
     setSelectedPricingOptionId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    selectedSlidingAmountInput: string;
+    setSelectedSlidingAmountInput: import("react").Dispatch<import("react").SetStateAction<string>>;
     selectedCoursePricing: Readonly<{
         currency: string;
         display: import("../../../blocks/courses/shared").CoursePriceDisplay;
         selectableOptions: readonly import("../../../blocks/courses/shared").CoursePricingOption[];
         requiresSelection: boolean;
         selectedOption: import("../../../blocks/courses/shared").CoursePricingOption | null;
+        slidingScale: Readonly<{
+            minAmount: number;
+            maxAmount: number;
+            suggestedAmount: number | null;
+        }> | null;
+        selectedSlidingAmount: number | null;
         selectedPriceAmount: number | null;
         selectedRequiresPayment: boolean;
         hasPaidSelection: boolean;

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

@@ -9,6 +9,14 @@ type TicketSelectionStepProps = {
     maxTickets: number;
     selectedTicketTypeId?: string | null;
     onTicketTypeChange?: (ticketTypeId: string) => void;
+    slidingScale?: Readonly<{
+        minAmount: number;
+        maxAmount: number;
+        suggestedAmount: number | null;
+    }> | null;
+    selectedSlidingAmountInput?: string;
+    slidingScaleSelectionMessage?: string | null;
+    onSlidingAmountChange?: (amount: string) => void;
     onTicketsChange: (count: number) => void;
 };
 /**

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

@@ -41,6 +41,7 @@ export declare function useEligibility(params: {
     occurrenceId: string;
     attendanceMode?: 'in_person' | 'online' | null;
     ticketTypeId: string | null;
+    selectedSlidingAmount?: number | null;
     email: string;
     ticketsCount: number;
 }): UseEligibilityResult;

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

@@ -43,7 +43,7 @@ export type EligibilityData = {
     /** Whether the selected event/ticket type currently requires payment. */
     requiresPayment: boolean;
     /** Persisted pricing mode for the underlying event series. */
-    pricingMode?: 'single' | 'ticket_types';
+    pricingMode?: 'single' | 'ticket_types' | 'sliding_scale';
     /** Selected ticket type echoed back from the eligibility API, if any. */
     selectedTicketTypeId?: string | null;
     /** Public ticket types available for selection in ticket-type mode. */

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

@@ -26,6 +26,7 @@ export declare function useEventRegistrationSubmit(options: {
     registrationTarget: RegistrationTarget | null;
     selectedAttendanceMode: 'in_person' | 'online' | null;
     selectedTicketTypeId: string | null;
+    selectedSlidingAmount: number | null;
     ticketsCount: number;
     formData: FormData;
     altchaSolution: string | null;

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

@@ -50,6 +50,15 @@ export declare function useEventRegistrationWizard(options: {
     setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>;
     selectedTicketTypeId: string | null;
     setSelectedTicketTypeId: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    selectedSlidingAmountInput: string;
+    setSelectedSlidingAmountInput: import("react").Dispatch<import("react").SetStateAction<string>>;
+    selectedSlidingAmount: number | null;
+    selectedEventSlidingScale: Readonly<{
+        minAmount: number;
+        maxAmount: number;
+        suggestedAmount: number | null;
+    }> | null;
+    slidingScaleSelectionMessage: string | null;
     selectedTicketType: import("./utils").SelectableEventTicketType | null;
     visibleTicketTypes: import("./utils").SelectableEventTicketType[];
     ticketTypeSelectionRequired: boolean;

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

@@ -6,6 +6,8 @@ type Brand<TValue, TBrand extends string> = TValue & {
 export type SlotKey = Brand<string, 'SlotKey'>;
 export type EntryBlockSlotId = Brand<string, 'EntryBlockSlotId'>;
 export type EntrySlotContentEntryId = Brand<string, 'EntrySlotContentEntryId'>;
+export type EntrySlotPageSurfaceId = Brand<string, 'EntrySlotPageSurfaceId'>;
+export type PageSurfaceSlotId = Brand<string, 'PageSurfaceSlotId'>;
 export type EntrySlotPageId = Brand<string, 'EntrySlotPageId'>;
 export type EntrySlotBlockId = Brand<string, 'EntrySlotBlockId'>;
 export type EntrySlotContentVersionId = Brand<string, 'EntrySlotContentVersionId'>;
@@ -41,12 +43,16 @@ export type NonEmptyStringParseError = Readonly<{
 export declare function unsafeAsSlotKey(value: string): SlotKey;
 export declare function unsafeAsEntryBlockSlotId(value: string): EntryBlockSlotId;
 export declare function unsafeAsEntrySlotContentEntryId(value: string): EntrySlotContentEntryId;
+export declare function unsafeAsEntrySlotPageSurfaceId(value: string): EntrySlotPageSurfaceId;
+export declare function unsafeAsPageSurfaceSlotId(value: string): PageSurfaceSlotId;
 export declare function unsafeAsEntrySlotPageId(value: string): EntrySlotPageId;
 export declare function unsafeAsEntrySlotBlockId(value: string): EntrySlotBlockId;
 export declare function unsafeAsEntrySlotContentVersionId(value: string): EntrySlotContentVersionId;
 export declare function unsafeAsEntrySlotBlockOrderIndex(value: number): EntrySlotBlockOrderIndex;
 export declare function parseSlotKey(value: unknown): EntrySlotResult<SlotKey, SlotKeyParseError>;
 export declare function parseEntryBlockSlotId(value: unknown): EntrySlotResult<EntryBlockSlotId, BrandedUuidParseError>;
+export declare function parseEntrySlotPageSurfaceId(value: unknown): EntrySlotResult<EntrySlotPageSurfaceId, BrandedUuidParseError>;
+export declare function parsePageSurfaceSlotId(value: unknown): EntrySlotResult<PageSurfaceSlotId, BrandedUuidParseError>;
 export declare const SYSTEM_ENTRY_SLOT_BLOCK_KIND: "system.entry-slot";
 export declare const DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS: readonly ["block.body-text", "block.rich-text", "block.image-gallery", "block.cta-full"];
 export type DefaultEntrySlotBlockKind = (typeof DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS)[number];
@@ -210,6 +216,33 @@ export type PublishedEntrySlotCompositionVersionDataV1 = Readonly<{
     blockSequence: readonly PublishedEntrySlotBlockSnapshot[];
 }>;
 export type EntrySlotCompositionVersionDataV1 = DraftEntrySlotCompositionVersionDataV1 | PublishedEntrySlotCompositionVersionDataV1;
+export type EntrySlotCompositionOwner = Readonly<{
+    kind: 'entrySlot';
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+}>;
+export type SurfaceSlotCompositionOwner = Readonly<{
+    kind: 'surfaceSlot';
+    surfaceSlotId: PageSurfaceSlotId;
+    pageSurfaceId: EntrySlotPageSurfaceId;
+}>;
+export type SlotCompositionOwner = EntrySlotCompositionOwner | SurfaceSlotCompositionOwner;
+export type DraftSlotCompositionVersionDataV2 = Readonly<{
+    schemaVersion: 2;
+    stage: 'draft';
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}>;
+export type PublishedSlotCompositionVersionDataV2 = Readonly<{
+    schemaVersion: 2;
+    stage: 'published';
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly PublishedEntrySlotBlockSnapshot[];
+}>;
+export type SlotCompositionVersionDataV2 = DraftSlotCompositionVersionDataV2 | PublishedSlotCompositionVersionDataV2;
+export type SlotCompositionVersionData = EntrySlotCompositionVersionDataV1 | SlotCompositionVersionDataV2;
 export type PublishedEntrySlotCompositionBuildError = Readonly<{
     kind: 'published-composition-contains-unpublished-block';
     blockId: EntrySlotBlockId;
@@ -221,12 +254,23 @@ export declare function buildDraftEntrySlotCompositionVersionData(input: {
     slotKey: SlotKey;
     blockSequence: readonly EntrySlotBlockSnapshot[];
 }): DraftEntrySlotCompositionVersionDataV1;
+export declare function entrySlotCompositionOwnerFromV1(versionData: EntrySlotCompositionVersionDataV1): EntrySlotCompositionOwner;
+export declare function buildDraftSlotCompositionVersionData(input: {
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): DraftSlotCompositionVersionDataV2;
 export declare function buildPublishedEntrySlotCompositionVersionData(input: {
     entrySlotId: EntryBlockSlotId;
     contentEntryId: EntrySlotContentEntryId;
     slotKey: SlotKey;
     blockSequence: readonly EntrySlotBlockSnapshot[];
 }): EntrySlotResult<PublishedEntrySlotCompositionVersionDataV1, PublishedEntrySlotCompositionBuildError>;
+export declare function buildPublishedSlotCompositionVersionData(input: {
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): EntrySlotResult<PublishedSlotCompositionVersionDataV2, PublishedEntrySlotCompositionBuildError>;
 export type EntrySlotCompositionParseError = Readonly<{
     kind: 'not-object';
 }> | Readonly<{
@@ -253,8 +297,33 @@ export type EntrySlotCompositionParseError = Readonly<{
     kind: 'published-composition-contains-unpublished-block';
     index: number;
 }>;
+export type SlotCompositionOwnerParseError = Readonly<{
+    kind: 'not-object';
+}> | Readonly<{
+    kind: 'unsupported-owner-kind';
+    ownerKind: unknown;
+}> | Readonly<{
+    kind: 'invalid-entry-slot-id';
+    error: BrandedUuidParseError | NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-surface-slot-id';
+    error: BrandedUuidParseError;
+}> | Readonly<{
+    kind: 'invalid-page-surface-id';
+    error: BrandedUuidParseError;
+}>;
+export type SlotCompositionParseError = EntrySlotCompositionParseError | Readonly<{
+    kind: 'invalid-owner';
+    error: SlotCompositionOwnerParseError;
+}>;
 export declare function parseEntrySlotCompositionVersionData(input: unknown): EntrySlotResult<EntrySlotCompositionVersionDataV1, EntrySlotCompositionParseError>;
+export declare function parseSlotCompositionVersionData(input: unknown): EntrySlotResult<SlotCompositionVersionData, SlotCompositionParseError>;
+export declare function parseSlotCompositionOwner(input: unknown): EntrySlotResult<SlotCompositionOwner, SlotCompositionOwnerParseError>;
 export declare function blockContentVersionIdsForEntrySlotCompositionVersionData(versionData: EntrySlotCompositionVersionDataV1): readonly EntrySlotContentVersionId[];
+export declare function blockContentVersionIdsForSlotCompositionVersionData(versionData: SlotCompositionVersionData): readonly EntrySlotContentVersionId[];
 export type SlotPublishPlan = Readonly<{
     kind: 'publishable';
     slotKey: SlotKey;
@@ -330,6 +399,15 @@ export declare function describeSdkEntryBlocksPatchParseError(error: SdkEntryBlo
 export type SlotContainerOwner = Readonly<{
     kind: 'contentEntry';
     contentEntryId: EntrySlotContentEntryId;
+}> | Readonly<{
+    kind: 'pageSurface';
+    pageSurfaceId: EntrySlotPageSurfaceId;
+}>;
+export type ContentEntrySlotContainerOwner = Extract<SlotContainerOwner, {
+    kind: 'contentEntry';
+}>;
+export type PageSurfaceSlotContainerOwner = Extract<SlotContainerOwner, {
+    kind: 'pageSurface';
 }>;
 export type SlotContainerOwnerParseError = Readonly<{
     kind: 'not-object';
@@ -339,10 +417,13 @@ export type SlotContainerOwnerParseError = Readonly<{
 }> | Readonly<{
     kind: 'invalid-content-entry-id';
     error: NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-page-surface-id';
+    error: BrandedUuidParseError;
 }>;
 export declare function parseSlotContainerOwner(input: unknown): EntrySlotResult<SlotContainerOwner, SlotContainerOwnerParseError>;
-export declare function slotContainerOwnerToContentVersionOwner(owner: SlotContainerOwner): ContentVersionOwner;
-export declare function slotContainerOwnerToEntrySlotLookup(owner: SlotContainerOwner): Readonly<{
+export declare function slotContainerOwnerToContentVersionOwner(owner: ContentEntrySlotContainerOwner): ContentVersionOwner;
+export declare function slotContainerOwnerToEntrySlotLookup(owner: ContentEntrySlotContainerOwner): Readonly<{
     contentEntryId: EntrySlotContentEntryId;
 }>;
 export type PlannedSlotCompositionBlockWrite = Readonly<{
@@ -401,6 +482,33 @@ export type EditableBlockOwner = Readonly<{
     kind: 'entry-slot';
     entrySlotId: EntryBlockSlotId;
 }>;
+export type SlotCompositionTransferReviewReason = Readonly<{
+    kind: 'target-is-not-surface-slot';
+    targetKind: SlotCompositionOwner['kind'];
+}>;
+export type SlotCompositionTransferPlan = Readonly<{
+    kind: 'noChange';
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'copyEntrySlotToSurfaceSlot';
+    from: EntrySlotCompositionOwner;
+    to: SurfaceSlotCompositionOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'forkSurfaceSlotComposition';
+    from: SurfaceSlotCompositionOwner;
+    to: SurfaceSlotCompositionOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'manualReviewRequired';
+    reason: SlotCompositionTransferReviewReason;
+}>;
+export declare function planSlotCompositionTransfer(input: Readonly<{
+    from: SlotCompositionOwner;
+    to: SlotCompositionOwner;
+    slotKey: SlotKey;
+}>): SlotCompositionTransferPlan;
 export type EntryLifecycleRecoveryCheckpoint = 'entry-fields' | 'route-metadata' | 'slot-composition' | 'block-published-refs' | 'cache-revalidation';
 export type EntryLifecycleCommitPlan = Readonly<{
     kind: 'transactional-commit';

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

@@ -28,6 +28,7 @@ export type SiteRouteId = Brand<string, 'SiteRouteId'>;
 export type PageId = Brand<string, 'PageId'>;
 export type PageSurfaceId = Brand<string, 'PageSurfaceId'>;
 export type OccurrenceId = Brand<string, 'OccurrenceId'>;
+export type EventOfferingId = Brand<string, 'EventOfferingId'>;
 export type EventSeriesId = Brand<string, 'EventSeriesId'>;
 export type TicketTypeId = Brand<string, 'TicketTypeId'>;
 export type EventCategoryId = Brand<string, 'EventCategoryId'>;
@@ -143,6 +144,7 @@ export declare const unsafeAsSiteRouteId: (id: string) => SiteRouteId;
 export declare const unsafeAsPageId: (id: string) => PageId;
 export declare const unsafeAsPageSurfaceId: (id: string) => PageSurfaceId;
 export declare const unsafeAsOccurrenceId: (id: string) => OccurrenceId;
+export declare const unsafeAsEventOfferingId: (id: string) => EventOfferingId;
 export declare const unsafeAsEventSeriesId: (id: string) => EventSeriesId;
 export declare const unsafeAsTicketTypeId: (id: string) => TicketTypeId;
 export declare const unsafeAsEventCategoryId: (id: string) => EventCategoryId;
@@ -232,6 +234,7 @@ export declare const parseSiteRouteId: (value: unknown) => Result<SiteRouteId, B
 export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdParseError>;
 export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;
 export declare const parseOccurrenceId: (value: unknown) => Result<OccurrenceId, BrandedIdParseError>;
+export declare const parseEventOfferingId: (value: unknown) => Result<EventOfferingId, BrandedIdParseError>;
 export declare const parseTicketTypeId: (value: unknown) => Result<TicketTypeId, BrandedIdParseError>;
 export declare const parsePricingOptionId: (value: unknown) => Result<PricingOptionId, BrandedIdParseError>;
 export declare const parseUserId: (value: unknown) => Result<UserId, BrandedIdParseError>;

package/dist/_dts/core/src/event-pricing.d.ts

@@ -1,5 +1,5 @@
 import { type CurrencyDecimals } from "./currency-format";
-export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types"];
+export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types", "sliding_scale"];
 export type EventPricingMode = (typeof EVENT_PRICING_MODES)[number];
 export type PublicEventPricingType = "free" | "paid" | "external";
 export type PublicCoursePriceDisplay = Readonly<{
@@ -13,6 +13,11 @@ export type PublicCoursePriceDisplay = Readonly<{
     kind: "from";
     amount: number;
     currency: string;
+}> | Readonly<{
+    kind: "range";
+    minAmount: number;
+    maxAmount: number;
+    currency: string;
 }> | Readonly<{
     kind: "unavailable";
     currency: string;
@@ -70,6 +75,18 @@ export type PublicEventPricing<TTicketType = never> = Readonly<{
     currency: string;
     ticketTypes: readonly TTicketType[];
     display: PublicEventTicketTypePriceDisplay;
+}> | Readonly<{
+    kind: "sliding_scale";
+    minAmount: number;
+    maxAmount: number;
+    suggestedAmount: number | null;
+    currency: string;
+    display: Readonly<{
+        kind: "range";
+        minAmount: number;
+        maxAmount: number;
+        currency: string;
+    }>;
 }> | Readonly<{
     kind: "course";
     display: Readonly<{

package/dist/_dts/core/src/money-input.d.ts

@@ -1,7 +1,8 @@
 import type { Brand } from './branded';
 import { type Result } from './result';
-export type PositiveMoneyCents = Brand<number, 'PositiveMoneyCents'>;
-export type NonNegativeMoneyCents = Brand<number, 'NonNegativeMoneyCents'>;
+export type Cents = Brand<number, 'Cents'>;
+export type NonNegativeCents = Brand<number, 'NonNegativeCents'>;
+export type PositiveCents = Brand<number, 'PositiveCents'>;
 export type MoneyInputParseError = Readonly<{
     kind: 'empty';
 }> | Readonly<{
@@ -11,6 +12,15 @@ export type MoneyInputParseError = Readonly<{
 }> | Readonly<{
     kind: 'zero-not-allowed';
 }>;
+export type CentsParseError = Readonly<{
+    kind: 'invalid-number';
+}> | Readonly<{
+    kind: 'not-whole-cents';
+}> | Readonly<{
+    kind: 'negative';
+}> | Readonly<{
+    kind: 'zero-not-allowed';
+}>;
 export type ParseMoneyInputToCentsOptions = Readonly<{
     allowZero?: boolean;
     stripFormatting?: boolean;
@@ -18,7 +28,27 @@ export type ParseMoneyInputToCentsOptions = Readonly<{
 export type ParseStrictMoneyInputToCentsOptions = Readonly<{
     stripFormatting?: boolean;
 }>;
-export declare function parsePositiveMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<PositiveMoneyCents, MoneyInputParseError>;
-export declare function parseNonNegativeMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<NonNegativeMoneyCents, MoneyInputParseError>;
+export declare function unsafeAsCents(value: number): Cents;
+export declare function unsafeAsNonNegativeCents(value: number): NonNegativeCents;
+export declare function unsafeAsPositiveCents(value: number): PositiveCents;
+export declare function unwrapCents(value: Cents): number;
+export declare function isWholeCents(value: number): boolean;
+export declare function isNonNegativeWholeCents(value: number): boolean;
+export declare function isPositiveWholeCents(value: number): boolean;
+/**
+ * Normalizes a derived amount to signed whole cents. Use parse*Cents for
+ * untrusted input that should fail instead of truncating or clamping.
+ */
+export declare function toCents(value: number): Cents;
+/**
+ * Normalizes a derived amount to non-negative whole cents. This intentionally
+ * clamps negatives to zero; use parseNonNegativeCents for validation.
+ */
+export declare function toNonNegativeCents(value: number): NonNegativeCents;
+export declare function parseCents(value: number): Result<Cents, CentsParseError>;
+export declare function parseNonNegativeCents(value: number): Result<NonNegativeCents, CentsParseError>;
+export declare function parsePositiveCents(value: number): Result<PositiveCents, CentsParseError>;
+export declare function parsePositiveMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<PositiveCents, MoneyInputParseError>;
+export declare function parseNonNegativeMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<NonNegativeCents, MoneyInputParseError>;
 export declare function parseMoneyInputToCents(value: string, options?: ParseMoneyInputToCentsOptions): number | null;
 export declare function formatMoneyInputFromCents(amountCents: number | null | undefined): string;