@riverbankcms/sdk 0.95.0 → 0.98.0

package/dist/_dts/blocks/src/system/runtime/api/endpoints.d.ts

@@ -52,6 +52,10 @@ export declare const BOOKINGS: {
         path: string;
         method: "GET";
     };
+    getWeeklySlotAvailability: {
+        path: string;
+        method: "GET";
+    };
     getAvailableDates: {
         path: string;
         method: "GET";
@@ -394,6 +398,10 @@ export declare const ENDPOINTS: {
             path: string;
             method: "GET";
         };
+        getWeeklySlotAvailability: {
+            path: string;
+            method: "GET";
+        };
         getAvailableDates: {
             path: string;
             method: "GET";

package/dist/_dts/blocks/src/system/runtime/api/types.d.ts

@@ -192,6 +192,30 @@ export interface TimeSlot {
 export interface AvailableSlotsResponse {
     slots: TimeSlot[];
 }
+export interface WeeklySlotAvailabilityRequest {
+    siteId: string;
+    serviceId: string;
+    resourceId?: string;
+    horizonWeeks?: number;
+    timezone: string;
+}
+export interface WeeklySlotAvailabilityOption {
+    id: string;
+    resourceId: string;
+    weekday: number;
+    weekdayLabel: string;
+    startTime: string;
+    endTime: string;
+    nextDate: string;
+    availableWeeks: number;
+}
+export interface WeeklySlotAvailabilityResponse {
+    slots: WeeklySlotAvailabilityOption[];
+    horizonWeeks: number;
+    timezone: string;
+    startDate: string;
+    endDate: string;
+}
 export interface AvailableDatesRequest {
     siteId: string;
     serviceId: string;

package/dist/_dts/blocks/src/system/runtime/components/registry.client.d.ts

@@ -8,6 +8,7 @@ import { AccordionNode, AccordionItemNode } from '../nodes/accordion';
 import HeaderSectionNode from '../nodes/header-section.client';
 import { EventCombinedIslandClient } from '../nodes/events';
 import { MediaNode } from '../nodes/media.client';
+import WeeklySlotAvailabilityClient from '../nodes/weekly-slot-availability.client';
 import { runtimeBackedBlockServerEntries, type RuntimeBackedBlockMode, type RuntimeBackedBlockKind, type RuntimeBackedClientBlockEntry, type RuntimeBackedClientComponentProps } from './runtime-backed-blocks';
 type SourcePropsClientEntry<TProps extends object = object> = Readonly<{
     kind: 'source-props';
@@ -28,6 +29,7 @@ export type ClientComponentRegistryEntryByKind = Readonly<{
     'event-details': ExplicitAdapterClientEntry<React.ComponentProps<typeof EventDetailsIslandClient>>;
     'location-map': ExplicitAdapterClientEntry<React.ComponentProps<typeof LocationMapIslandClient>>;
     'event-combined': ExplicitAdapterClientEntry<React.ComponentProps<typeof EventCombinedIslandClient>>;
+    'weekly-slot-availability': SourcePropsClientEntry<React.ComponentProps<typeof WeeklySlotAvailabilityClient>>;
 }>;
 export type ClientComponentRegistryEntry = ClientComponentRegistryEntryByKind[keyof ClientComponentRegistryEntryByKind];
 export declare function defineSourcePropsClientEntry<TProps extends object>(component: React.ComponentType<TProps>): SourcePropsClientEntry<TProps>;
@@ -2992,6 +2994,10 @@ export declare const clientComponentRegistryEntries: {
         }>>;
         produces: "client-props" | "island-props";
     }>;
+    readonly 'weekly-slot-availability': Readonly<{
+        kind: "source-props";
+        component: React.ComponentType<import("../nodes/weekly-slot-availability.client").WeeklySlotAvailabilityClientProps>;
+    }>;
 };
 export declare const clientComponentRegistry: ComponentRegistry;
 export {};

package/dist/_dts/blocks/src/system/runtime/hooks/useAppointmentCheckoutVerification.d.ts

@@ -1,4 +1,6 @@
+import { useBlockApi } from "../api";
 import { type AppointmentCheckoutVerificationState } from "../nodes/booking-form.state";
+import { usePolling } from "./usePolling";
 export type AppointmentCheckoutVerificationConfig = {
     sessionId: string;
     maxAttempts?: number;
@@ -8,4 +10,9 @@ export type AppointmentCheckoutVerificationResult = {
     state: AppointmentCheckoutVerificationState;
     retry: () => void;
 };
+export type AppointmentCheckoutVerificationDeps = Readonly<{
+    useBlockApi: typeof useBlockApi;
+    usePolling: typeof usePolling;
+}>;
 export declare function useAppointmentCheckoutVerification(config: AppointmentCheckoutVerificationConfig | null): AppointmentCheckoutVerificationResult;
+export declare function useAppointmentCheckoutVerificationWithDeps(config: AppointmentCheckoutVerificationConfig | null, deps: AppointmentCheckoutVerificationDeps): AppointmentCheckoutVerificationResult;

package/dist/_dts/blocks/src/system/runtime/hooks/useAvailableSlots.d.ts

@@ -6,14 +6,14 @@
  */
 import { type TimeSlot } from "../api";
 export type { TimeSlot };
-type UseAvailableSlotsOptions = {
+export type UseAvailableSlotsOptions = {
     siteId: string;
     serviceId: string | undefined;
     resourceId: string | undefined;
     selectedDate: string;
     timezone: string;
 };
-type UseAvailableSlotsResult = {
+export type UseAvailableSlotsResult = {
     slots: TimeSlot[];
     isLoading: boolean;
     isRefreshing: boolean;

package/dist/_dts/blocks/src/system/runtime/hooks/useHeadlessEventRegistrationFlow.d.ts

@@ -27,7 +27,11 @@ export type EventRegistrationController = Readonly<{
 export type EventRegistrationWizardController = Readonly<{
     wizard: ReturnType<typeof useEventRegistrationWizard>;
 }>;
+export type EventRegistrationControllerDeps = Readonly<{
+    useEventRegistrationWizard: typeof useEventRegistrationWizard;
+}>;
 export declare function HeadlessEventRegistrationProvider({ config, children, }: HeadlessEventRegistrationProviderProps): React.ReactElement;
 export declare function useHeadlessEventRegistrationFlow(options: HeadlessEventRegistrationFlowOptions): HeadlessEventRegistrationFlow;
 export declare function useEventRegistrationController(options: HeadlessEventRegistrationFlowOptions): EventRegistrationController;
+export declare function useEventRegistrationControllerWithDeps(options: HeadlessEventRegistrationFlowOptions, deps: EventRegistrationControllerDeps): EventRegistrationController;
 export declare function useEventRegistrationWizardController(options: HeadlessEventRegistrationFlowOptions): EventRegistrationWizardController;

package/dist/_dts/blocks/src/system/runtime/hooks/usePaymentVerification.d.ts

@@ -23,6 +23,7 @@
  * }, [verification.status]);
  * ```
  */
+import { useBlockApi } from '../api';
 import type { PaymentStatus, AttendeeStatus } from '../api/types';
 export type PaymentVerificationConfig = {
     /** Unique ID to check (attendeeId, customerPassId, etc.) */
@@ -46,6 +47,9 @@ export type PaymentVerificationResult = {
     /** Manually trigger a poll (useful for retry after timeout) */
     retry: () => void;
 };
+export type PaymentVerificationDeps = Readonly<{
+    useBlockApi: typeof useBlockApi;
+}>;
 /**
  * Hook for polling payment status after Stripe redirects.
  *
@@ -56,3 +60,4 @@ export type PaymentVerificationResult = {
  * @returns Verification result with status, data, and retry function
  */
 export declare function usePaymentVerification(config: PaymentVerificationConfig | null): PaymentVerificationResult;
+export declare function usePaymentVerificationWithDeps(config: PaymentVerificationConfig | null, deps: PaymentVerificationDeps): PaymentVerificationResult;

package/dist/_dts/blocks/src/system/runtime/nodes/basic.d.ts

@@ -2,11 +2,12 @@ import React from 'react';
 import { type ButtonSizeName } from '../../../../../theme-core/src/buttons/index';
 import type { PreviewLinkedEntryFieldBinding } from '../../data';
 export type TextNodeProps = {
-    value?: React.ReactNode;
+    value?: unknown;
     className?: string;
     path?: string;
     linkedEntryField?: PreviewLinkedEntryFieldBinding;
     maxLength?: number;
+    inlineTextFallbackPath?: string;
     children?: React.ReactNode;
 };
 export declare const TextNode: React.FC<TextNodeProps & {

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

@@ -4,6 +4,7 @@
  * Custom hooks for portal authentication and eligibility checking.
  * Extracted from the main EventRegistrationClient for better separation of concerns.
  */
+import { useBlockApi } from '../../api';
 import type { EventTicketSelectionLine } from './types';
 import { type EligibilityLookupState, type ExistingRegistrationLookupState } from './hooks.state';
 export type PortalAuthState = 'checking' | 'authenticated' | 'unauthenticated';
@@ -24,6 +25,9 @@ export type UsePortalAuthResult = {
     /** Logout function */
     logout: () => void;
 };
+export type EventRegistrationHooksDeps = Readonly<{
+    useBlockApi: typeof useBlockApi;
+}>;
 /**
  * Hook for managing portal authentication state.
  *
@@ -31,6 +35,7 @@ export type UsePortalAuthResult = {
  * fetches the portal profile if so.
  */
 export declare function usePortalAuth(): UsePortalAuthResult;
+export declare function usePortalAuthWithDeps(deps: EventRegistrationHooksDeps): UsePortalAuthResult;
 export type UseEligibilityResult = {
     state: EligibilityLookupState;
     eligibility: EligibilityLookupState['eligibility'];
@@ -45,6 +50,14 @@ export declare function useEligibility(params: {
     selectedSlidingAmount?: number | null;
     email: string;
 }): UseEligibilityResult;
+export declare function useEligibilityWithDeps(params: {
+    enabled: boolean;
+    occurrenceId: string;
+    attendanceMode?: 'in_person' | 'online' | null;
+    ticketSelections: readonly EventTicketSelectionLine[];
+    selectedSlidingAmount?: number | null;
+    email: string;
+}, deps: EventRegistrationHooksDeps): UseEligibilityResult;
 export type UseExistingEventRegistrationResult = {
     state: ExistingRegistrationLookupState;
     registration: ExistingRegistrationLookupState['registration'];
@@ -55,4 +68,5 @@ type UseExistingEventRegistrationParams = {
     occurrenceId: string;
 };
 export declare function useExistingEventRegistration({ isAuthenticated, occurrenceId, }: UseExistingEventRegistrationParams): UseExistingEventRegistrationResult;
+export declare function useExistingEventRegistrationWithDeps({ isAuthenticated, occurrenceId, }: UseExistingEventRegistrationParams, deps: EventRegistrationHooksDeps): UseExistingEventRegistrationResult;
 export {};

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

@@ -1,4 +1,5 @@
 import type { BlockApiClient } from '../../api';
+import { savePendingRegistration } from './sessionStorage';
 import type { EventTicketSelectionLine, FormData, Guest, RegistrationResult, RegistrationStep, PaymentSelection } from './types';
 import type { PaymentMethod } from '../../api/types';
 import type { RegistrationTarget } from './registrationDerivations';
@@ -21,7 +22,7 @@ export type EventRegistrationSubmitResult = Readonly<{
     reason: 'blocked' | 'missing-target' | 'submission-failed';
     message: string;
 }>;
-export declare function useEventRegistrationSubmit(options: {
+export type UseEventRegistrationSubmitInput = {
     api: BlockApiClient;
     registrationTarget: RegistrationTarget | null;
     selectedAttendanceMode: 'in_person' | 'online' | null;
@@ -37,4 +38,9 @@ export declare function useEventRegistrationSubmit(options: {
     setStep: (step: RegistrationStep) => void;
     setRegistrationResult: (result: RegistrationResult) => void;
     setErrorMessage: (message: string) => void;
-}): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+};
+export type EventRegistrationSubmitDeps = Readonly<{
+    savePendingRegistration: typeof savePendingRegistration;
+}>;
+export declare function useEventRegistrationSubmit(options: UseEventRegistrationSubmitInput): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;
+export declare function useEventRegistrationSubmitWithDeps(options: UseEventRegistrationSubmitInput, deps: EventRegistrationSubmitDeps): (method: PaymentMethod, passId?: string, membershipId?: string, selection?: PaymentSelection, submitOptions?: EventRegistrationSubmitOptions) => Promise<EventRegistrationSubmitResult>;

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/renderInlineText.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { InlineText } from '../../inlineText';
+export declare function renderInlineText(value: InlineText): React.ReactNode;

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/index.d.ts

@@ -20,6 +20,7 @@ export { useUISelector } from './ui/useUISelector';
 export { EditorUiStoreProvider, useEditorUiStore, useEditorUiStoreInstance, useOptionalEditorUiStoreInstance, createEditorUiStore } from './ui/editorUiStore';
 export type { ActivePreviewField, EditorUiStoreInstance, EditorUiState, EditorPreviewInspectorStore, EditorLinkedEntrySnapshot, PreviewInspection, PreviewSidebarTab, ViewportMode, ViewportWidth, ViewportState, ZoomLevel, } from './ui/editorUiStore';
 export { PreviewTextEditor } from './primitives/PreviewTextEditor';
+export { PreviewInlineTextEditor } from './primitives/PreviewInlineTextEditor';
 export { PreviewRichTextEditor } from './primitives/PreviewRichTextEditor';
 export { useStoreBinding, parseEditorPath } from './primitives/shared';
 export type { PathInfo } from './primitives/shared';

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

@@ -0,0 +1,9 @@
+import type { TextProps } from '../../../blocks/src/index';
+type PreviewInlineTextEditorProps = TextProps & {
+    path: string;
+    plainTextPath: string;
+    fallbackPlainText?: string;
+    onBlockFieldFocus?: (path: string) => void;
+};
+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/bindingTypeCompatibility.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ContentFieldConfig } from '../content-types/schema';
 export type ContentFieldType = ContentFieldConfig['type'];
-export type BlockFieldType = 'text' | 'number' | 'slug' | 'url' | 'richText' | 'media' | 'file' | 'boolean' | 'select' | 'reference' | 'link' | 'date' | 'datetime' | 'repeater';
+export type BlockFieldType = 'text' | 'inlineText' | 'number' | 'slug' | 'url' | 'richText' | 'media' | 'file' | 'boolean' | 'select' | 'reference' | 'link' | 'date' | 'datetime' | 'repeater';
 export type ScalarBlockFieldType = Exclude<BlockFieldType, 'repeater'>;
 export declare function isScalarBlockFieldType(type: string): type is ScalarBlockFieldType;
 export type MetaFieldType = 'text' | 'date' | 'enum';

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

@@ -54,6 +54,12 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                     source: "meta";
                     path: "title";
                 }>;
+                readonly headlineInline: Readonly<{
+                    source: "transform";
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
+                    input?: import("./types").TemplateBindingDescriptor | string;
+                    path?: string;
+                }>;
                 readonly subheadline: Readonly<{
                     source: "fallback";
                     options: import("./types").TemplateBindingValue[];
@@ -107,6 +113,12 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                     source: "meta";
                     path: "title";
                 }>;
+                readonly headlineInline: Readonly<{
+                    source: "transform";
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
+                    input?: import("./types").TemplateBindingDescriptor | string;
+                    path?: string;
+                }>;
                 readonly subheadline: Readonly<{
                     source: "fallback";
                     options: import("./types").TemplateBindingValue[];
@@ -177,6 +189,12 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                     source: "meta";
                     path: "title";
                 }>;
+                readonly headlineInline: Readonly<{
+                    source: "transform";
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
+                    input?: import("./types").TemplateBindingDescriptor | string;
+                    path?: string;
+                }>;
                 readonly subheadline: Readonly<{
                     source: "fallback";
                     options: import("./types").TemplateBindingValue[];
@@ -235,6 +253,12 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                     source: "meta";
                     path: "title";
                 }>;
+                readonly headlineInline: Readonly<{
+                    source: "transform";
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
+                    input?: import("./types").TemplateBindingDescriptor | string;
+                    path?: string;
+                }>;
                 readonly subheadline: Readonly<{
                     source: "field";
                     path: "intro";
@@ -280,6 +304,12 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                     source: "meta";
                     path: "title";
                 }>;
+                readonly headlineInline: Readonly<{
+                    source: "transform";
+                    transform: import("../../../field-primitives/src/bindings/index").BindingTransformName;
+                    input?: import("./types").TemplateBindingDescriptor | string;
+                    path?: string;
+                }>;
                 readonly subheadline: Readonly<{
                     source: "fallback";
                     options: import("./types").TemplateBindingValue[];