@riverbankcms/sdk 0.96.0 → 0.98.0

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

@@ -1,5 +1,10 @@
 import type { DiscountContext } from '../../api/types';
 import type { EventTicketSelectionLine, EventRegistrationClientProps, FormData, Guest, GuestErrors, PaymentSelection, PaymentStepState, PublicEvent, RegistrationEvent, RegistrationResult, RegistrationStep } from './types';
+import { usePortalAuth, useEligibility, useExistingEventRegistration } from './hooks';
+import { useWaitlistClaim } from '../../shared/useWaitlistClaim';
+import { useEventRegistrationStripeReturn } from './useEventRegistrationStripeReturn';
+import { useEventRegistrationSubmit } from './useEventRegistrationSubmit';
+import { useDiscountCodeUi } from './useDiscountCodeUi';
 export type EventRegistrationDetailsCompleteResult = Readonly<{
     ok: true;
     outcome: 'payment-step' | 'submitted';
@@ -8,13 +13,139 @@ export type EventRegistrationDetailsCompleteResult = Readonly<{
     reason: 'blocked' | 'validation-failed' | 'submission-failed';
     message: string;
 }>;
-export declare function useEventRegistrationWizard(options: {
+export type UseEventRegistrationWizardOptions = Readonly<{
     anchorId: string;
     occurrenceContext: EventRegistrationClientProps['occurrenceContext'];
     contentEntry: EventRegistrationClientProps['contentEntry'];
     events: PublicEvent[];
     maxTicketsNum: number;
-}): {
+}>;
+export type EventRegistrationWizardDeps = Readonly<{
+    usePortalAuth: typeof usePortalAuth;
+    useEligibility: typeof useEligibility;
+    useExistingEventRegistration: typeof useExistingEventRegistration;
+    useWaitlistClaim: typeof useWaitlistClaim;
+    useEventRegistrationStripeReturn: typeof useEventRegistrationStripeReturn;
+    useEventRegistrationSubmit: typeof useEventRegistrationSubmit;
+    useDiscountCodeUi: typeof useDiscountCodeUi;
+}>;
+export declare function useEventRegistrationWizard(options: UseEventRegistrationWizardOptions): {
+    api: import("../../api").BlockApiClient;
+    anchorId: string;
+    occurrenceContext: {
+        id: string;
+        seriesId: string;
+        startsAt: string;
+        endsAt: string;
+        timeZone: string;
+        capacityOverride?: number | null | undefined;
+        overrides?: Record<string, unknown> | null | undefined;
+    } | null | undefined;
+    registrationTarget: Readonly<{
+        occurrenceId: string;
+        selectedEventId: string | null;
+    }> | null;
+    contentEntry: {
+        id: string;
+        slug: string;
+        contentTypeSlug: string;
+    } | null | undefined;
+    events: PublicEvent[];
+    maxTicketsNum: number;
+    scopedEvents: RegistrationEvent[];
+    preSelectedEvent: RegistrationEvent | null;
+    hasPreSelectedContext: boolean;
+    step: RegistrationStep;
+    setStep: (nextStep: RegistrationStep) => void;
+    selectedEvent: RegistrationEvent | null;
+    setSelectedEvent: import("react").Dispatch<import("react").SetStateAction<RegistrationEvent | null>>;
+    ticketsCount: number;
+    setTicketsCount: (nextTicketsCount: number) => void;
+    selectedAttendanceMode: "in_person" | "online" | null;
+    setSelectedAttendanceMode: import("react").Dispatch<import("react").SetStateAction<"in_person" | "online" | null>>;
+    ticketSelections: Readonly<{
+        ticketTypeId: string | null;
+        quantity: number;
+    }>[];
+    selectedTicketLines: Readonly<{
+        ticketTypeId: string | null;
+        quantity: number;
+    }>[];
+    setSelectedTicketLines: (lines: readonly EventTicketSelectionLine[]) => void;
+    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;
+    ticketSelectionSummaryLines: Readonly<{
+        ticketTypeId: string | null;
+        label: string;
+        quantity: number;
+        unitPriceCents: number;
+        subtotalCents: number;
+    }>[];
+    ticketSelectionSubtotalCents: number;
+    visibleTicketTypes: import("./utils").SelectableEventTicketType[];
+    ticketTypeSelectionRequired: boolean;
+    hasValidTicketSelection: boolean;
+    eventRequiresPayment: boolean;
+    formData: FormData;
+    setFormData: import("react").Dispatch<import("react").SetStateAction<FormData>>;
+    errors: Partial<Record<keyof FormData, string>>;
+    guests: Guest[];
+    setGuests: import("react").Dispatch<import("react").SetStateAction<Guest[]>>;
+    guestErrors: GuestErrors;
+    guestSectionShake: boolean;
+    handleGuestShakeEnd: () => void;
+    registrationResult: RegistrationResult | null;
+    errorMessage: string;
+    altchaSolution: string | null;
+    setAltchaSolution: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    portalAuthState: import("./hooks").PortalAuthState;
+    portalProfile: import("./hooks").PortalProfile | null;
+    showMagicLinkModal: boolean;
+    setShowMagicLinkModal: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    handleLogout: () => void;
+    paymentStepState: PaymentStepState;
+    handlePaymentStepStateChange: (state: PaymentStepState) => void;
+    handlePaymentSelectionChange: (selection: PaymentSelection) => void;
+    paymentSelection: PaymentSelection;
+    isMembershipFastTrack: boolean;
+    waitlistClaim: import("../../shared/useWaitlistClaim").UseWaitlistClaimResult;
+    eligibility: import("./types").EligibilityData | null;
+    eligibilityLoading: boolean;
+    eligibilityError: string | null;
+    existingRegistration: import("../../api").CustomerEventRegistration | null;
+    existingRegistrationLoading: boolean;
+    existingRegistrationState: import("./hooks.state").ExistingRegistrationLookupState;
+    hasEligibility: boolean;
+    hasMembershipEligibility: boolean;
+    requireGuestDetails: boolean;
+    discountCode: string;
+    setDiscountCode: (code: string) => void;
+    discountUiOpen: boolean;
+    setDiscountUiOpen: (isOpen: boolean) => void;
+    discountsAvailable: boolean;
+    manualCodeEntryAllowed: boolean;
+    autoAppliedDiscount: import("../../api/types").AutoAppliedDiscountPreview | null;
+    discountsAvailableLoading: boolean;
+    discountContext: DiscountContext | null;
+    shouldShowDiscountToggle: boolean;
+    verification: import("../../hooks/usePaymentVerification").PaymentVerificationResult;
+    handleDetailsComplete: () => Promise<EventRegistrationDetailsCompleteResult>;
+    handlePaymentSelect: () => Promise<void>;
+    handleUseCardInsteadOfPass: () => void;
+    handleBookForSomeoneElse: () => void;
+    handleSubmit: (method: import("./PaymentSelectionStep").PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: import("./useEventRegistrationSubmit").EventRegistrationSubmitOptions) => Promise<import("./useEventRegistrationSubmit").EventRegistrationSubmitResult>;
+    handleEventSelect: (event: RegistrationEvent) => void;
+    handleRetry: () => void;
+};
+export declare function useEventRegistrationWizardWithDeps(options: UseEventRegistrationWizardOptions, deps: EventRegistrationWizardDeps): {
     api: import("../../api").BlockApiClient;
     anchorId: string;
     occurrenceContext: {

package/dist/_dts/blocks/src/system/runtime/nodes/weekly-slot-availability.client.controller.d.ts

@@ -0,0 +1,3 @@
+import type { BlockApiClient } from "../api";
+import { type WeeklySlotAvailabilityClientInput, type WeeklySlotAvailabilityLoadState } from "./weekly-slot-availability.client.state";
+export declare function useWeeklySlotAvailabilityLoadState(api: BlockApiClient, input: WeeklySlotAvailabilityClientInput): WeeklySlotAvailabilityLoadState;

package/dist/_dts/blocks/src/system/runtime/nodes/weekly-slot-availability.client.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { WeeklySlotAvailabilityClientInput } from "./weekly-slot-availability.client.state";
+export type WeeklySlotAvailabilityClientProps = WeeklySlotAvailabilityClientInput & Readonly<{
+    emptyMessage?: string | null;
+    ctaText?: string | null;
+    ctaUrl?: string | null;
+}>;
+export declare function WeeklySlotAvailabilityClient({ serviceId, resourceId, horizonWeeks, timezone, availability: initialAvailability, emptyMessage, ctaText, ctaUrl, }: WeeklySlotAvailabilityClientProps): React.JSX.Element;
+export default WeeklySlotAvailabilityClient;

package/dist/_dts/blocks/src/system/runtime/nodes/weekly-slot-availability.client.state.d.ts

@@ -0,0 +1,14 @@
+import type { WeeklySlotAvailabilityResponse } from "../api/types";
+export type WeeklySlotAvailabilityClientInput = Readonly<{
+    serviceId?: string | null;
+    resourceId?: string | null;
+    horizonWeeks?: number | string | null;
+    timezone?: string | null;
+    availability?: WeeklySlotAvailabilityResponse | null;
+}>;
+export type WeeklySlotAvailabilityLoadState = Readonly<{
+    availability: WeeklySlotAvailabilityResponse | null;
+    loading: boolean;
+    error: string | null;
+}>;
+export declare function normalizeWeeklySlotAvailabilityHorizonWeeks(value: WeeklySlotAvailabilityClientInput["horizonWeeks"]): number;

package/dist/_dts/blocks/src/system/runtime/nodes/weekly-slot-availability.server.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { WeeklySlotAvailabilityResponse } from "../api/types";
+export type WeeklySlotAvailabilityNodeProps = Readonly<{
+    availability?: WeeklySlotAvailabilityResponse | null;
+    emptyMessage?: string | null;
+    ctaText?: string | null;
+    ctaUrl?: string | null;
+}>;
+export declare function WeeklySlotAvailabilitySSR(props: WeeklySlotAvailabilityNodeProps): React.JSX.Element;
+export default WeeklySlotAvailabilitySSR;

package/dist/_dts/blocks/src/system/runtime/nodes/weekly-slot-availability.view.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { WeeklySlotAvailabilityResponse } from "../api/types";
+export type WeeklySlotAvailabilityViewProps = Readonly<{
+    availability?: WeeklySlotAvailabilityResponse | null;
+    loading?: boolean;
+    error?: string | null;
+    emptyMessage?: string | null;
+    ctaText?: string | null;
+    ctaUrl?: string | null;
+}>;
+export declare function WeeklySlotAvailabilityView({ availability, loading, error, emptyMessage, ctaText, ctaUrl, }: WeeklySlotAvailabilityViewProps): React.JSX.Element;

package/dist/_dts/blocks/src/system/runtime/resolver.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import type { NodeDefinition } from "../node";
+import type { ConditionalAuthoringPresence, NodeDefinition } from "../node";
 import { bindingSchema } from "../node";
 import { type ThemeTokens } from "../theme";
 import type { TransformRegistry, RouteMap, PageIdentifierMap, EntryIdentifierMap } from "../transforms";
@@ -10,6 +10,14 @@ export type PreviewTextFieldConstraints = Readonly<{
     maxLength?: number;
 }>;
 export type PreviewFieldConstraintsMap = Readonly<Record<string, PreviewTextFieldConstraints | undefined>>;
+export type PreviewAuthoringContext = Readonly<{
+    activeField?: PreviewAuthoringActiveField | null;
+}>;
+export type PreviewAuthoringActiveField = Readonly<{
+    kind: 'block-field';
+    blockId: string;
+    fieldPath: string;
+}>;
 export type ResolverContext = {
     viewModel: ViewModel;
     registry: ComponentRegistry;
@@ -29,6 +37,7 @@ export type ResolverContext = {
     fragmentRegistry?: Record<string, unknown>;
     fieldConstraints?: PreviewFieldConstraintsMap;
     imageResolveContext?: ResolveImageUrlContext;
+    previewAuthoring?: PreviewAuthoringContext;
 };
 /** @internal Exported for testing */
 export type ScopeEntry = {
@@ -46,6 +55,26 @@ export type ScopeEntry = {
 export type InternalContext = ResolverContext & {
     scopes: ScopeEntry[];
 };
+type ConditionalValuePresence = Readonly<{
+    kind: 'present';
+}> | Readonly<{
+    kind: 'empty';
+}>;
+export type ConditionalNodeRenderDecision = Readonly<{
+    kind: 'render';
+    reason: 'condition-passed' | 'authoring-presence';
+}> | Readonly<{
+    kind: 'skip';
+    reason: 'condition-failed' | 'not-editable' | 'inactive-authoring-context';
+}>;
+export declare function planConditionalNodeRender(input: {
+    readonly conditionMatched: boolean;
+    readonly conditionPresence: ConditionalValuePresence;
+    readonly conditionUsesPresenceSemantics: boolean;
+    readonly authoringPresence: ConditionalAuthoringPresence;
+    readonly editableTarget: PreviewAuthoringActiveField | null;
+    readonly authoringContext: PreviewAuthoringContext | undefined;
+}): ConditionalNodeRenderDecision;
 /**
  * Resolves a binding to its value from the viewModel or scopes.
  * Applies transforms and fallback handling.
@@ -68,3 +97,4 @@ export declare function resolveNode(node: NodeDefinition, context: InternalConte
  * Accepts a single node or array of nodes and returns React elements.
  */
 export declare function resolveTree(node: NodeDefinition | NodeDefinition[], options: ResolverContext): React.ReactNode;
+export {};

package/dist/_dts/blocks/src/system/runtime/shared/useWaitlistClaim.d.ts

@@ -1,3 +1,4 @@
+import { useBlockApi } from "../api";
 import type { ResolveWaitlistClaimResponse } from "../api/types";
 export declare function getWaitlistClaimTokenFromUrl(): string | null;
 export type UseWaitlistClaimResult = {
@@ -8,4 +9,8 @@ export type UseWaitlistClaimResult = {
     requiresPortalLogin: boolean;
     isLoading: boolean;
 };
+export type UseWaitlistClaimDeps = Readonly<{
+    useBlockApi: typeof useBlockApi;
+}>;
 export declare function useWaitlistClaim(): UseWaitlistClaimResult;
+export declare function useWaitlistClaimWithDeps(deps: UseWaitlistClaimDeps): UseWaitlistClaimResult;

package/dist/_dts/blocks/src/utils/date-formatting.d.ts

@@ -17,7 +17,7 @@ export declare function getRuntimeTimeZone(): string;
  * @param days - Number of days to generate
  * @returns Array of date strings
  */
-export declare function generateDateRange(days: number): string[];
+export declare function generateDateRange(days: number, from?: Date): string[];
 /**
  * Formats an ISO date string (YYYY-MM-DD) to a human-readable format
  * @param dateStr - ISO date string (e.g., "2025-03-15")

package/dist/_dts/content-editor/src/primitives/PreviewInlineTextEditor.d.ts

@@ -5,5 +5,5 @@ type PreviewInlineTextEditorProps = TextProps & {
     fallbackPlainText?: string;
     onBlockFieldFocus?: (path: string) => void;
 };
-export declare function PreviewInlineTextEditor({ path, plainTextPath, fallbackPlainText, onBlockFieldFocus, className, maxLength, as: Comp, }: PreviewInlineTextEditorProps): import("react").JSX.Element | null;
+export declare function PreviewInlineTextEditor({ path, plainTextPath, fallbackPlainText, onBlockFieldFocus, className, maxLength, placeholder, ariaLabel, as: Comp, }: PreviewInlineTextEditorProps): import("react").JSX.Element | null;
 export {};

package/dist/_dts/content-editor/src/primitives/PreviewRichTextEditor.d.ts

@@ -8,5 +8,5 @@ type PreviewRichTextEditorProps = RichTextPrimitiveProps & {
  * Memoized version to prevent unnecessary re-renders.
  * Only re-renders when path, doc, variant, or className props actually change.
  */
-export declare const PreviewRichTextEditor: import("react").MemoExoticComponent<({ path, linkedEntryField, onLinkedEntryFieldFocus, onBlockFieldFocus, className, doc, variant }: PreviewRichTextEditorProps) => import("react").JSX.Element>;
+export declare const PreviewRichTextEditor: import("react").MemoExoticComponent<({ path, linkedEntryField, onLinkedEntryFieldFocus, onBlockFieldFocus, className, doc, variant, placeholder, ariaLabel, }: PreviewRichTextEditorProps) => import("react").JSX.Element>;
 export {};

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

@@ -56,7 +56,7 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 }>;
                 readonly headlineInline: Readonly<{
                     source: "transform";
-                    transform: import("./types").TemplateBindingTransformName;
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
                     input?: import("./types").TemplateBindingDescriptor | string;
                     path?: string;
                 }>;
@@ -115,7 +115,7 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 }>;
                 readonly headlineInline: Readonly<{
                     source: "transform";
-                    transform: import("./types").TemplateBindingTransformName;
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
                     input?: import("./types").TemplateBindingDescriptor | string;
                     path?: string;
                 }>;
@@ -191,7 +191,7 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 }>;
                 readonly headlineInline: Readonly<{
                     source: "transform";
-                    transform: import("./types").TemplateBindingTransformName;
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
                     input?: import("./types").TemplateBindingDescriptor | string;
                     path?: string;
                 }>;
@@ -255,7 +255,7 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 }>;
                 readonly headlineInline: Readonly<{
                     source: "transform";
-                    transform: import("./types").TemplateBindingTransformName;
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
                     input?: import("./types").TemplateBindingDescriptor | string;
                     path?: string;
                 }>;
@@ -306,7 +306,7 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 }>;
                 readonly headlineInline: Readonly<{
                     source: "transform";
-                    transform: import("./types").TemplateBindingTransformName;
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
                     input?: import("./types").TemplateBindingDescriptor | string;
                     path?: string;
                 }>;

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

@@ -1,16 +1,12 @@
+import { type BindingTransformName } from '../../../field-primitives/src/bindings/index';
 export type TemplateScope = 'entry' | 'template';
-/**
- * Keep in sync with:
- * - @riverbankcms/blocks `TRANSFORMS`
- * - @riverbankcms/sdk `BINDING_TRANSFORMS`
- */
 export declare const TEMPLATE_BINDING_TRANSFORMS: {
     readonly RICHTEXT_FIRST_PARAGRAPH: "richtext.firstParagraph";
     readonly DATE_FORMAT_SHORT: "date.formatShort";
     readonly DATE_FORMAT_LONG: "date.formatLong";
     readonly TEXT_INLINE_TEXT: "text.inlineText";
 };
-export type TemplateBindingTransformName = typeof TEMPLATE_BINDING_TRANSFORMS[keyof typeof TEMPLATE_BINDING_TRANSFORMS];
+export type TemplateBindingTransformName = BindingTransformName;
 export type TemplateBindingDescriptor = {
     source: 'field' | 'meta';
     path: string;

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

@@ -72,6 +72,9 @@ export type EnrollmentId = Brand<string, 'EnrollmentId'>;
 export type AppointmentId = Brand<string, 'AppointmentId'>;
 export type AppointmentServiceId = Brand<string, 'AppointmentServiceId'>;
 export type AppointmentResourceId = Brand<string, 'AppointmentResourceId'>;
+export type AppointmentReservationId = Brand<string, 'AppointmentReservationId'>;
+export type AppointmentReservationRunId = Brand<string, 'AppointmentReservationRunId'>;
+export type AppointmentPaymentRequestId = Brand<string, 'AppointmentPaymentRequestId'>;
 export type StaffMemberId = Brand<string, 'StaffMemberId'>;
 export type BookingCalendarFeedTokenId = Brand<string, 'BookingCalendarFeedTokenId'>;
 export type BookingCalendarFeedTokenPublicId = Brand<string, 'BookingCalendarFeedTokenPublicId'>;
@@ -188,6 +191,9 @@ export declare const unsafeAsEnrollmentId: (id: string) => EnrollmentId;
 export declare const unsafeAsAppointmentId: (id: string) => AppointmentId;
 export declare const unsafeAsAppointmentServiceId: (id: string) => AppointmentServiceId;
 export declare const unsafeAsAppointmentResourceId: (id: string) => AppointmentResourceId;
+export declare const unsafeAsAppointmentReservationId: (id: string) => AppointmentReservationId;
+export declare const unsafeAsAppointmentReservationRunId: (id: string) => AppointmentReservationRunId;
+export declare const unsafeAsAppointmentPaymentRequestId: (id: string) => AppointmentPaymentRequestId;
 export declare const unsafeAsStaffMemberId: (id: string) => StaffMemberId;
 export declare const unsafeAsBookingCalendarFeedTokenId: (id: string) => BookingCalendarFeedTokenId;
 export declare const unsafeAsBookingCalendarFeedTokenPublicId: (id: string) => BookingCalendarFeedTokenPublicId;
@@ -250,6 +256,8 @@ export declare const parsePassId: (value: unknown) => Result<PassId, BrandedIdPa
 export declare const parseMembershipId: (value: unknown) => Result<MembershipId, BrandedIdParseError>;
 export declare const parseCourseId: (value: unknown) => Result<CourseId, BrandedIdParseError>;
 export declare const parseAppointmentId: (value: unknown) => Result<AppointmentId, BrandedIdParseError>;
+export declare const parseAppointmentReservationId: (value: unknown) => Result<AppointmentReservationId, BrandedIdParseError>;
+export declare const parseAppointmentReservationRunId: (value: unknown) => Result<AppointmentReservationRunId, BrandedIdParseError>;
 export declare const parseAttendeeId: (value: unknown) => Result<AttendeeId, BrandedIdParseError>;
 export declare const parseCustomerId: (value: unknown) => Result<CustomerId, BrandedIdParseError>;
 export declare const parseCustomerMembershipId: (value: unknown) => Result<CustomerMembershipId, BrandedIdParseError>;