@riverbankcms/sdk 0.145.0 → 0.147.0

package/dist/_dts/api/src/pageSurfaceEndpoints.d.ts

@@ -0,0 +1,44 @@
+import type { APIEndpoint } from './apiEndpointTypes';
+import type { PageSurfaceEditorDocument, PublishPageSurfaceResponse } from './contentRuntime';
+import type { SaveEventPageWordsPayload, SaveEventPageWordsResponse } from './eventPageWords';
+import type { RouteMetadataPayload } from './routes';
+import type { ContentRouteRecord } from './types';
+/**
+ * The authoritative page surface behind an event's page: its content draft,
+ * its route metadata, its publication, and the words the Content tab owns.
+ */
+export type PageSurfaceAPIEndpoints = {
+    updatePageSurfaceDraftContent: APIEndpoint<{
+        data: Record<string, unknown>;
+        optimisticHash: string;
+    }, {
+        siteId: string;
+        pageSurfaceId: string;
+    }, {
+        document: PageSurfaceEditorDocument;
+    }>;
+    discardPageSurfaceDraftContent: APIEndpoint<{
+        optimisticHash: string;
+    }, {
+        siteId: string;
+        pageSurfaceId: string;
+    }, {
+        document: PageSurfaceEditorDocument;
+    }>;
+    updatePageSurfaceRouteMetadata: APIEndpoint<Pick<RouteMetadataPayload, 'draftSlug' | 'draftMetaTitle' | 'draftMetaDescription' | 'ogImageId'> & {
+        expectedDraftUpdatedAt: string | null;
+    }, {
+        siteId: string;
+        pageSurfaceId: string;
+    }, {
+        route: ContentRouteRecord;
+    }>;
+    publishPageSurface: APIEndpoint<never, {
+        siteId: string;
+        pageSurfaceId: string;
+    }, PublishPageSurfaceResponse>;
+    saveEventPageWords: APIEndpoint<SaveEventPageWordsPayload, {
+        siteId: string;
+        pageSurfaceId: string;
+    }, SaveEventPageWordsResponse>;
+};

package/dist/_dts/api/src/participantMessaging.d.ts

@@ -11,7 +11,12 @@ export type ParticipantMessageTarget = {
     eventSeriesId: string;
     includeStatuses: WholeSeriesParticipantMessageStatus[];
 };
-export type WholeSeriesParticipantMessageStatus = Extract<EventSeriesRegistrationStatus, 'enrolled' | 'completed'>;
+/**
+ * Which people on a run a message may reach. `waitlist` is only ever included
+ * when the sender asks for it, which is what the "people waiting" tick on the
+ * run's Messages tab turns on.
+ */
+export type WholeSeriesParticipantMessageStatus = Extract<EventSeriesRegistrationStatus, 'enrolled' | 'completed' | 'waitlist'>;
 export type GetParticipantMessageRecipientsRequest = {
     target: ParticipantMessageTarget;
 };
@@ -106,6 +111,11 @@ export type ParticipantMessageHistoryEntry = {
     batchId: string;
     target: ParticipantMessageTarget;
     subject: string;
+    /**
+     * What was written, so a sent message can be read back and sent again. Null
+     * for a batch whose stored payload predates this field.
+     */
+    bodyText: string | null;
     recipientCount: number;
     sentCount: number;
     queuedCount: number;

package/dist/_dts/api/src/publicAppointmentBookingContracts.d.ts

@@ -0,0 +1,48 @@
+import type { BookingMailingListNote as BookingSignupNote } from '../../core/src/index';
+export type PublicCreateBookingAppointmentRequest = {
+    formId: string;
+    serviceId: string;
+    resourceId?: string | null;
+    startAt: string;
+    endAt: string;
+    customFields: Record<string, unknown>;
+    mailingListOptIn?: boolean;
+    timezone?: string;
+    discountCode?: string;
+    selectedSlidingAmount?: number;
+    selectedCollectionOptionKind?: 'upfront' | 'deferred_manual' | 'instalment_plan' | 'flexible_balance';
+    altchaSolution?: string | null;
+    successUrl?: string;
+    cancelUrl?: string;
+};
+export type PublicBookingAppointmentSummary = {
+    id: string;
+    status: 'confirmed' | 'pending' | 'cancelled';
+    startAt: string;
+    endAt: string;
+    timezone: string;
+    resourceName: string | null;
+};
+export type PublicBookingCustomerSummary = {
+    id: string;
+    email: string | null;
+    name: string | null;
+    phone: string | null;
+};
+export type PublicCreateBookingAppointmentResponse = {
+    type: 'booked';
+    orderId: string;
+    orderNumber: string;
+    appointment: PublicBookingAppointmentSummary;
+    customer: PublicBookingCustomerSummary;
+    mailingListSignupNote?: BookingSignupNote;
+} | {
+    type: 'checkout_redirect';
+    orderId: string;
+    orderNumber: string;
+    checkoutUrl: string;
+    sessionId: string;
+    appointment: PublicBookingAppointmentSummary;
+    customer: PublicBookingCustomerSummary;
+    mailingListSignupNote?: BookingSignupNote;
+};

package/dist/_dts/api/src/publicExperience/eventEndpoints.d.ts

@@ -1,3 +1,4 @@
+import type { BookingMailingListNote as BookingSignupNote } from '../../../core/src/index';
 /**
  * Storefront event discovery, registration, checkout and eligibility endpoints.
  *
@@ -120,6 +121,7 @@ export type PublicEventAPIEndpoints = {
         notes?: string;
         formData?: Record<string, unknown>;
         consentAccepted?: boolean;
+        mailingListOptIn?: boolean;
         altchaSolution?: string | null;
         paymentMethod?: 'free' | 'pass' | 'membership' | 'stripe' | 'pass_bundle' | 'membership_bundle';
         customerPassId?: string;
@@ -160,6 +162,7 @@ export type PublicEventAPIEndpoints = {
         phone?: string;
         formData?: Record<string, unknown>;
         consentAccepted?: boolean;
+        mailingListOptIn?: boolean;
         altchaSolution?: string | null;
         guests?: Array<{
             name: string;
@@ -185,6 +188,7 @@ export type PublicEventAPIEndpoints = {
             amountCents: number;
             currency: string;
         };
+        mailingListSignupNote?: BookingSignupNote;
     } | {
         scope: 'wholeSeries';
         registrationId: string;
@@ -197,17 +201,20 @@ export type PublicEventAPIEndpoints = {
             amountCents: number;
             currency: string;
         };
+        mailingListSignupNote?: BookingSignupNote;
     } | {
         scope: 'wholeSeries';
         status: 'paymentStatusRequired';
         checkoutAttemptId: string;
         recoverableUntil?: string;
+        mailingListSignupNote?: BookingSignupNote;
     } | {
         scope: 'wholeSeries';
         status: 'waitlist';
         waitlistEntryId: string;
         waitlistPosition: number | null;
         alreadyRegistered?: boolean;
+        mailingListSignupNote?: BookingSignupNote;
     }>;
     getPublicEventRegistrationOptions: APIEndpoint<PublicEventRegistrationOptionsRequest, {
         siteId: string;

package/dist/_dts/api/src/sdk-event-upsert.d.ts

@@ -1,3 +1,5 @@
+import type { AttendeeNotificationIntent } from './occurrenceScheduling';
+import type { SdkCourseBookingSettings } from './sdkCourseBooking';
 import type { SdkEntryUpsertSlotBlock, SdkEventBookingOffer, SdkEventContentInput, SdkPullEvent, SdkPullEventRun, SdkEventUpsertScheduleInput } from './sdkContracts';
 import { type BookingTimeZone, type UtcIsoDateTimeString } from '../../core/src/index';
 export { classifySdkEventBookingOffer } from './sdk-event-booking-offer';
@@ -10,6 +12,45 @@ export declare const sdkEventOccurrenceInputSchema: z.ZodObject<{
     endsAt: z.ZodString;
     timeZone: z.ZodString;
 }, z.core.$strip>;
+/**
+ * A course's own booking settings, as they are pulled and pushed on the Event.
+ * One schema for both directions and for the CLI's site commands, so the three
+ * cannot drift apart.
+ */
+export declare const sdkCourseBookingSettingsSchema: z.ZodObject<{
+    visibility: z.ZodEnum<{
+        public: "public";
+        unlisted: "unlisted";
+    }>;
+    acceptsPasses: z.ZodBoolean;
+    acceptsMemberships: z.ZodBoolean;
+    ticketingMode: z.ZodOptional<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+        inherit: "inherit";
+    }>>;
+    collectAllAttendeeDetails: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    cancellationPolicy: z.ZodObject<{
+        refunds: z.ZodObject<{
+            mode: z.ZodEnum<{
+                never: "never";
+                inherit: "inherit";
+                always: "always";
+                cutoff: "cutoff";
+            }>;
+            cutoffHours: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        transfers: z.ZodObject<{
+            mode: z.ZodEnum<{
+                never: "never";
+                inherit: "inherit";
+                always: "always";
+                cutoff: "cutoff";
+            }>;
+            cutoffHours: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export declare const sdkEventUpsertOptionalFieldSchemas: {
     readonly path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     readonly status: z.ZodOptional<z.ZodEnum<{
@@ -20,7 +61,6 @@ export declare const sdkEventUpsertOptionalFieldSchemas: {
         cancelled: "cancelled";
     }>>;
     readonly visibility: z.ZodOptional<z.ZodEnum<{
-        private: "private";
         public: "public";
         unlisted: "unlisted";
     }>>;
@@ -108,6 +148,12 @@ type SdkEventRunExplicitOccurrencesInput = Readonly<{
 export type SdkEventRunUpsertBody = SdkEventRunUpsertCommon & (SdkEventRunAuthoredScheduleInput | SdkEventRunExplicitOccurrencesInput);
 export type SdkEventUpsertBody = Readonly<{
     identifier: string;
+    /**
+     * A course's listing, passes, memberships and refund policy, written onto
+     * every one of its runs in one go. Only a course may send it; leaving it out
+     * leaves those settings as they are.
+     */
+    courseBooking?: SdkCourseBookingSettings;
     administrativeStatus?: SdkPullEvent['administrativeStatus'];
     title: string;
     slug: string;
@@ -117,6 +163,14 @@ export type SdkEventUpsertBody = Readonly<{
     content?: SdkEventContentInput;
     blocks?: Record<string, SdkEntryUpsertSlotBlock[]>;
     runs: readonly [SdkEventRunUpsertBody, ...SdkEventRunUpsertBody[]];
+    /**
+     * Whether the people booked hear about a venue change this push makes.
+     * Leaving it out never emails anyone: a push is a file sync, and a stale
+     * local file could otherwise move a run back to an old venue and tell
+     * everyone the wrong place. Same shape as the dashboard's "let everyone
+     * booked know" tick.
+     */
+    attendeeNotification?: AttendeeNotificationIntent;
 }>;
 export type ValidatedSdkEventRunUpsertInput = SdkEventRunUpsertBody & Readonly<{
     timingAuthority: SdkEventTimingAuthority;

package/dist/_dts/api/src/sdkContracts.d.ts

@@ -2,14 +2,13 @@ import type { SdkSiteLayoutConfig } from './sdkConfig/layout';
 export type { SdkSiteLayoutConfig } from './sdkConfig/layout';
 import type { BlockContentSource, BlockContentSourceKind, FieldDefinition, FieldDefinitionInput, SdkCustomBlock, SdkCustomBlockInput, Theme } from '../../blocks/src/index';
 import type { ContentTypeSchema } from '../../content-model/src/index';
-import type { EventPreset, FooterCompositionV1, RichTextDoc } from '../../core/src/index';
+import type { FooterCompositionV1, RichTextDoc } from '../../core/src/index';
 export type { SdkBlockAppearanceChoice, SdkBlockAppearanceOutcome, } from './sdkBlockUpsertContracts';
 import type { LinkPayload } from './navigation/types';
 import type { JsonValue } from './shared-contracts';
 import type { EventBookingOfferIntent } from '@riverbankcms/site-commands';
 import type { ManagementMediaAsset } from './sdkMediaContracts';
 export type { ManagementMediaAsset, SdkMediaDeleteApplyResponse, SdkMediaDeletePreviewResponse, SdkMediaDownloadResponse, SdkMediaListResponse, } from './sdkMediaContracts';
-import type { SdkPullEventOccurrence } from './sdk-event-schedule';
 import type { SiteCommandApplicationResult } from '@riverbankcms/site-commands';
 import type { SdkThemeWire } from './sdkThemeWire';
 import type { SdkCatalogButtonStyleControl } from './sdkThemeCatalogContracts';
@@ -770,46 +769,8 @@ export interface SdkPullEventCategoriesResponse {
     eventCategories: SdkPullEventCategory[];
     meta: SdkPullMeta;
 }
-export interface SdkPullEvent {
-    identifier: string;
-    administrativeStatus: 'active' | 'archived';
-    title: string;
-    slug: string;
-    path: string | null;
-    preset: EventPreset;
-    runRefs: readonly [string, ...string[]];
-    content: {
-        summary?: string;
-        body?: RichTextDoc;
-        image?: Record<string, unknown> & {
-            identifier: string;
-        };
-        [key: string]: unknown;
-    };
-    updatedAt: string;
-    createdAt: string;
-    contentUpdatedAt: string | null;
-    blocks?: SdkEntrySlotBlocks;
-}
-export interface SdkPullEventRun {
-    identifier: string;
-    eventRef: string;
-    name: string | null;
-    status: 'draft' | 'active' | 'archived' | 'cancelled' | 'completed';
-    visibility: 'private' | 'public' | 'unlisted';
-    bookingScope: 'single_occurrence' | 'whole_series';
-    occurrences: readonly SdkPullEventOccurrence[];
-    capacity: number | null;
-    bookingOffer: SdkEventBookingOffer;
-    venueRef: string | null;
-    categoryRef: string | null;
-    formRef: string | null;
-    settings: Record<string, unknown>;
-    presentation: Record<string, unknown> | null;
-    tags: string[];
-    updatedAt: string;
-    createdAt: string;
-}
+export type { SdkPullEvent, SdkPullEventRun } from './sdkPullEventContracts';
+import type { SdkPullEvent, SdkPullEventRun } from './sdkPullEventContracts';
 export type { SdkPullEventOccurrence } from './sdk-event-schedule';
 export type SdkEventContentInput = {
     summary?: string;

package/dist/_dts/api/src/sdkCourseBooking.d.ts

@@ -0,0 +1,30 @@
+import type { z } from 'zod';
+import type { courseBookingSettingsSchema } from '@riverbankcms/site-commands';
+import type { CourseBookingSettingsRequest } from './eventManagementContracts';
+/**
+ * The booking settings a course owns for every one of its runs: where it is
+ * listed, whether passes and memberships may be used, QR tickets, guest details
+ * and the refunds and transfers policy.
+ *
+ * Storage is per run, but a run may not be written for them — the course is the
+ * single writer — so they are pulled and pushed on the Event and are absent
+ * from every whole-series run.
+ *
+ * Taken from the schema that validates a push, so the wire shape and what the
+ * parser admits cannot drift apart.
+ */
+export type SdkCourseBookingSettings = z.infer<typeof courseBookingSettingsSchema>;
+type Assert<T extends true> = T;
+/**
+ * The pushed settings and the management API's own request are the same
+ * fields; if either changes without the other, this stops compiling.
+ */
+export type SdkCourseBookingSettingsMatchesRequest = Assert<SdkCourseBookingSettings extends CourseBookingSettingsRequest ? CourseBookingSettingsRequest extends SdkCourseBookingSettings ? true : false : false>;
+/**
+ * Carried by the pulled Event. Present only for a course: an ordinary event
+ * owns its own listing and passes, on the run itself.
+ */
+export interface SdkPulledCourseBooking {
+    courseBooking?: SdkCourseBookingSettings;
+}
+export {};

package/dist/_dts/api/src/sdkEventEndpointDefinitions.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The SDK's Event graph: the Events themselves and the occurrences of one run.
+ * Extracted from `endpoints.ts` so this family can be read, and added to, on
+ * its own. New entries here must declare `errors`; the
+ * require-api-endpoint-errors lint enforces that here as in endpoints.ts.
+ */
+export declare const SDK_EVENT_ENDPOINT_DEFINITIONS: {
+    sdkListEvents: {
+        path: "/sdk/{siteId}/events";
+        method: "GET";
+        auth: "service";
+        responseKind: "json";
+    };
+    sdkUpsertEvent: {
+        path: "/sdk/{siteId}/events";
+        method: "POST";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "resource:conflict" | "billing:plan_limit_exceeded" | "server:internal_error")[];
+    };
+    sdkGetEvent: {
+        path: "/sdk/{siteId}/events/{identifier}";
+        method: "GET";
+        auth: "service";
+        responseKind: "json";
+    };
+    sdkDeleteEvent: {
+        path: "/sdk/{siteId}/events/{identifier}";
+        method: "DELETE";
+        auth: "service";
+        responseKind: "json";
+        errors: ("resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+    sdkTakeEventOffline: {
+        path: "/sdk/{siteId}/events/{identifier}/lifecycle";
+        method: "POST";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+    sdkListEventOccurrences: {
+        path: "/sdk/{siteId}/events/{identifier}/runs/{runIdentifier}/occurrences";
+        method: "GET";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "server:internal_error")[];
+    };
+    sdkAddEventOccurrence: {
+        path: "/sdk/{siteId}/events/{identifier}/runs/{runIdentifier}/occurrences";
+        method: "POST";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+    sdkUpdateEventOccurrence: {
+        path: "/sdk/{siteId}/events/{identifier}/runs/{runIdentifier}/occurrences/{occurrenceId}";
+        method: "PATCH";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+    sdkCancelEventOccurrence: {
+        path: "/sdk/{siteId}/events/{identifier}/runs/{runIdentifier}/occurrences/{occurrenceId}/cancel";
+        method: "POST";
+        auth: "service";
+        responseKind: "json";
+        errors: ("resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+    sdkDeleteEventOccurrence: {
+        path: "/sdk/{siteId}/events/{identifier}/runs/{runIdentifier}/occurrences/{occurrenceId}";
+        method: "DELETE";
+        auth: "service";
+        responseKind: "json";
+        errors: ("resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+};

package/dist/_dts/api/src/sdkEventLifecycle.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The SDK management lifecycle contract for parent Events.
+ *
+ * Lifecycle is deliberately a single operation: a management key can take an
+ * Event offline, and nothing else. There is no put-online, no archive or
+ * restore, and no cancel (issue 1495). The endpoint itself is declared in
+ * `sdkEventEndpointDefinitions.ts`.
+ */
+import type { EventSeriesId } from '../../core/src/index';
+import type { APIEndpoint } from './apiEndpointTypes';
+/**
+ * An `applied` outcome always changed something: at least one run, or the
+ * Event page. Running the operation again on an Event that is already offline
+ * reports `already-offline` rather than failing.
+ */
+export type SdkTakeEventOfflineResponse = Readonly<{
+    kind: 'applied';
+    changedRunIds: readonly [EventSeriesId, ...EventSeriesId[]];
+    pageTakenOffline: boolean;
+}> | Readonly<{
+    kind: 'applied';
+    changedRunIds: readonly [];
+    pageTakenOffline: true;
+}> | Readonly<{
+    kind: 'already-offline';
+}>;
+export type SdkTakeEventOfflineBody = Readonly<{
+    command: Readonly<{
+        kind: 'takeOfferingOffline';
+    }>;
+}>;
+export type SdkEventLifecycleAPIEndpoints = {
+    sdkTakeEventOffline: APIEndpoint<SdkTakeEventOfflineBody, {
+        siteId: string;
+        identifier: string;
+    }, SdkTakeEventOfflineResponse>;
+};

package/dist/_dts/api/src/sdkManagedEventContracts.d.ts

@@ -1,8 +1,26 @@
 import type { EventOccurrenceStatus } from './bookingRecords';
+import type { EventPageState } from './eventManagementContracts';
 import type { EventOfferingId, EventSeriesId, OccurrenceId } from '../../core/src/index';
 import type { SdkEventCanonicalScheduleInput, SdkPullEvent, SdkPullEventRun } from './sdkContracts';
 export type SdkManagementEvent = SdkPullEvent & {
     id: EventOfferingId;
+    /**
+     * Whether the Event's own page is currently reachable by the public, derived
+     * from its route exactly as the dashboard's lifecycle service derives it
+     * (`EventPageState`): published means `online`, anything else `offline`.
+     *
+     * Read-only, and deliberately absent from the portable pull/upsert shape: a
+     * page goes online or offline through lifecycle operations, never by being
+     * written back in an event file.
+     *
+     * Optional only for the length of one release, for the same reason as
+     * `confirmedPlaces` below. A published CLI can be pointed at a dashboard
+     * that predates this field, and making it required would fail the whole
+     * event response parse rather than one column. Make it required once every
+     * dashboard carrying this change is live. While it is absent, a client
+     * cannot prove the page state and must say so rather than assume.
+     */
+    pageState?: EventPageState;
 };
 export type SdkManagementEventRun = SdkPullEventRun & {
     id: EventSeriesId;