@riverbankcms/sdk 0.146.0 → 0.148.0

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

@@ -1,13 +1,33 @@
+import type { DiscardPageSurfaceResponse } from './documentLifecycle';
 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 Content tab's save: the same draft write as
+ * `updatePageSurfaceDraftContent`, which the server follows with a publish when
+ * the event books on another website and its page is online (a draft there
+ * could never be seen). `visibility` says which happened.
+ */
+export type SaveEventContentTabResponse = Readonly<{
+    document: PageSurfaceEditorDocument;
+}> & (Readonly<{
+    visibility: 'draft';
+}> | Readonly<{
+    visibility: 'live';
+    publication: PublishPageSurfaceResponse;
+}>);
 /**
  * The authoritative page surface behind an event's page: its content draft,
- * its route metadata, its publication, and the words the Content tab owns.
+ * its route metadata and its publication.
  */
 export type PageSurfaceAPIEndpoints = {
+    getPageSurfaceEditorDocument: APIEndpoint<never, {
+        siteId: string;
+        pageSurfaceId: string;
+    }, {
+        document: PageSurfaceEditorDocument;
+    }>;
     updatePageSurfaceDraftContent: APIEndpoint<{
         data: Record<string, unknown>;
         optimisticHash: string;
@@ -22,9 +42,7 @@ export type PageSurfaceAPIEndpoints = {
     }, {
         siteId: string;
         pageSurfaceId: string;
-    }, {
-        document: PageSurfaceEditorDocument;
-    }>;
+    }, DiscardPageSurfaceResponse>;
     updatePageSurfaceRouteMetadata: APIEndpoint<Pick<RouteMetadataPayload, 'draftSlug' | 'draftMetaTitle' | 'draftMetaDescription' | 'ogImageId'> & {
         expectedDraftUpdatedAt: string | null;
     }, {
@@ -37,8 +55,11 @@ export type PageSurfaceAPIEndpoints = {
         siteId: string;
         pageSurfaceId: string;
     }, PublishPageSurfaceResponse>;
-    saveEventPageWords: APIEndpoint<SaveEventPageWordsPayload, {
+    saveEventContentTab: APIEndpoint<{
+        data: Record<string, unknown>;
+        optimisticHash: string;
+    }, {
         siteId: string;
         pageSurfaceId: string;
-    }, SaveEventPageWordsResponse>;
+    }, SaveEventContentTabResponse>;
 };

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

@@ -19,17 +19,17 @@ type SavePageDesignStateOptions = PageMutationOptions & {
 type ApplyPageDesignEditorActionOptions = PageMutationOptions & {
     body: NonNullable<APIEndpoints['applyPageDesignEditorAction']['body']>;
 };
-export declare function createPage(apiClient: ApiClient, { siteId, name, path, purpose, options }: CreatePageOptions): Promise<{
+export declare function createPage(apiClient: ApiClient<'createContentEntry'>, { siteId, name, path, purpose, options }: CreatePageOptions): Promise<{
     page: PageRecord;
 }>;
-export declare function publishPageDraft(apiClient: ApiClient, { siteId, pageId, options }: PageMutationOptions): Promise<{
+export declare function publishPageDraft(apiClient: ApiClient<'publishContentEntry'>, { siteId, pageId, options }: PageMutationOptions): Promise<{
     page: PageRecord;
 }>;
-export declare function discardPageDraft(apiClient: ApiClient, { siteId, pageId, options }: PageMutationOptions): Promise<{
+export declare function discardPageDraft(apiClient: ApiClient<'discardContentEntry'>, { siteId, pageId, options }: PageMutationOptions): Promise<{
     page: PageRecord;
 }>;
-export declare function savePageDesignState(apiClient: ApiClient, { siteId, pageId, body, options }: SavePageDesignStateOptions): Promise<NonNullable<APIEndpoints['savePageDesignState']['response']>>;
-export declare function getPageDesignEditorState(apiClient: ApiClient, { siteId, pageId, options }: PageMutationOptions): Promise<NonNullable<APIEndpoints['getPageDesignEditorState']['response']>>;
-export declare function applyPageDesignEditorAction(apiClient: ApiClient, { siteId, pageId, body, options }: ApplyPageDesignEditorActionOptions): Promise<NonNullable<APIEndpoints['applyPageDesignEditorAction']['response']>>;
-export declare function deletePage(apiClient: ApiClient, { siteId, pageId, options }: PageMutationOptions): Promise<DeleteContentEntryResponse>;
+export declare function savePageDesignState(apiClient: ApiClient<'savePageDesignState'>, { siteId, pageId, body, options }: SavePageDesignStateOptions): Promise<NonNullable<APIEndpoints['savePageDesignState']['response']>>;
+export declare function getPageDesignEditorState(apiClient: ApiClient<'getPageDesignEditorState'>, { siteId, pageId, options }: PageMutationOptions): Promise<NonNullable<APIEndpoints['getPageDesignEditorState']['response']>>;
+export declare function applyPageDesignEditorAction(apiClient: ApiClient<'applyPageDesignEditorAction'>, { siteId, pageId, body, options }: ApplyPageDesignEditorActionOptions): Promise<NonNullable<APIEndpoints['applyPageDesignEditorAction']['response']>>;
+export declare function deletePage(apiClient: ApiClient<'deleteContentEntry'>, { siteId, pageId, options }: PageMutationOptions): Promise<DeleteContentEntryResponse>;
 export {};

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

@@ -1,3 +1,3 @@
 import type { ApiClient } from './request';
 import type { PerformanceOverviewQuery, PerformanceOverviewResponse } from './seo';
-export declare function getPerformanceOverview(apiClient: ApiClient, query: PerformanceOverviewQuery, options?: RequestInit): Promise<PerformanceOverviewResponse>;
+export declare function getPerformanceOverview(apiClient: ApiClient<'getPerformanceOverview'>, query: PerformanceOverviewQuery, options?: RequestInit): Promise<PerformanceOverviewResponse>;

package/dist/_dts/api/src/public/index.d.ts

@@ -15,5 +15,5 @@ export { PUBLIC_ENDPOINT_NAMES, type PublicEndpointName, isPublicEndpoint } from
 export { formatIgnoredDocumentSyncSectionWarning, } from '../sdkContracts';
 export { decodePublicProductCategorySelectorQuery, encodePublicProductCategorySelector, parsePublicProductCategorySelector, } from '../publicProducts';
 export type { PublicProductCategorySelector, PublicProductCategorySelectorQuery, } from '../publicProducts';
-export { createBearerAPIClient, createInternalAPIClient, ApiRequestError, setSdkVersion, getSdkVersion, type ApiClient } from '../request';
+export { createBearerAPIClient, createInternalAPIClient, ApiRequestError, setSdkVersion, getSdkVersion, type ApiClient, type OrdinaryApiClient, type OrdinaryEndpointKey } from '../request';
 export * from '../common/envelope';

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

@@ -0,0 +1,50 @@
+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;
+    demoBookingPass?: string;
+} | {
+    type: 'checkout_redirect';
+    orderId: string;
+    orderNumber: string;
+    checkoutUrl: string;
+    sessionId: string;
+    appointment: PublicBookingAppointmentSummary;
+    customer: PublicBookingCustomerSummary;
+    mailingListSignupNote?: BookingSignupNote;
+    demoBookingPass?: string;
+};

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

@@ -138,9 +138,11 @@ export type PublicCommerceAPIEndpoints = {
         type: 'redirect';
         checkoutUrl: string;
         sessionId: string;
+        demoBookingPass?: string;
     } | {
         type: 'bypassed';
         sessionId: null;
+        demoBookingPass?: string;
     } | {
         type: 'duplicate_membership_warning';
         message: string;
@@ -214,10 +216,12 @@ export type PublicCommerceAPIEndpoints = {
         sessionId: string;
         orderId: string | null;
         orderNumber: string | null;
+        demoBookingPass?: string;
     } | {
         type: 'bypassed';
         orderId: string | null;
         orderNumber: string | null;
+        demoBookingPass?: string;
     }>;
     getDiscountsAvailable: APIEndpoint<{
         subtotalCents?: number;

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

@@ -32,16 +32,16 @@ export type CreateRedirectRuleResponse = {
 export type DeleteRedirectRuleResponse = {
     redirects: RedirectRuleRecord[];
 };
-export declare function listRedirectRules(apiClient: ApiClient, { siteId, options }: {
+export declare function listRedirectRules(apiClient: ApiClient<'listRedirectRules'>, { siteId, options }: {
     siteId: string;
     options?: RequestInit;
 }): Promise<ListRedirectRulesResponse>;
-export declare function createRedirectRule(apiClient: ApiClient, { siteId, body, options, }: {
+export declare function createRedirectRule(apiClient: ApiClient<'createRedirectRule'>, { siteId, body, options, }: {
     siteId: string;
     body: CreateRedirectRuleRequest;
     options?: RequestInit;
 }): Promise<CreateRedirectRuleResponse>;
-export declare function deleteRedirectRule(apiClient: ApiClient, { siteId, ruleId, options }: {
+export declare function deleteRedirectRule(apiClient: ApiClient<'deleteRedirectRule'>, { siteId, ruleId, options }: {
     siteId: string;
     ruleId: string;
     options?: RequestInit;

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

@@ -1,4 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
+import { type ManagedEditLeaseEndpointKey } from "./endpoints";
 import type { AuthHeaders } from "./token";
 import type * as ApiTypes from "./types";
 import { type CmsApiBaseUrl } from "./url";
@@ -16,11 +17,19 @@ export declare function getSdkVersion(): string | undefined;
 type ApiCallParams<E extends keyof ApiTypes.APIEndpoints> = ApiTypes.APICallParamsStrict<E>;
 type EndpointResponse<E extends keyof ApiTypes.APIEndpoints> = ApiTypes.APIEndpoints[E]['response'];
 type ApiResponseFor<E extends keyof ApiTypes.APIEndpoints> = EndpointResponse<E> extends undefined ? void : NonNullable<EndpointResponse<E>>;
+declare const apiClientEndpoints: unique symbol;
 /**
  * API client that returns typed envelope responses.
  * Consumers must use isApiSuccess/isApiError type guards or unwrapResponse helper.
  */
-export type ApiClient = <E extends keyof ApiTypes.APIEndpoints>(params: ApiCallParams<E>) => Promise<ApiResult<ApiResponseFor<E>>>;
+export type ApiClient<Allowed extends keyof ApiTypes.APIEndpoints = keyof ApiTypes.APIEndpoints> = {
+    <E extends Allowed>(params: ApiCallParams<E>): Promise<ApiResult<ApiResponseFor<E>>>;
+    /** Preserve capability contravariance when a client is passed to another helper. */
+    readonly [apiClientEndpoints]?: (endpoint: Allowed) => void;
+};
+/** Ordinary browser operations cannot issue writes owned by an editor lease. */
+export type OrdinaryEndpointKey = Exclude<keyof ApiTypes.APIEndpoints, ManagedEditLeaseEndpointKey>;
+export type OrdinaryApiClient = ApiClient<OrdinaryEndpointKey>;
 export interface ApiRequestErrorOptions {
     endpoint: keyof ApiTypes.APIEndpoints;
     status: number;

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

@@ -1,6 +1,6 @@
 import type { ApiClient } from './request';
 import type { AppointmentResource, CreateAppointmentResourceRequest, UpdateAppointmentResourceRequest } from './types';
-export declare function listAppointmentResourcesRequest(apiClient: ApiClient, siteId: string, options?: RequestInit): Promise<AppointmentResource[]>;
-export declare function createAppointmentResourceRequest(apiClient: ApiClient, siteId: string, payload: CreateAppointmentResourceRequest, options?: RequestInit): Promise<AppointmentResource>;
-export declare function updateAppointmentResourceRequest(apiClient: ApiClient, siteId: string, resourceId: string, payload: UpdateAppointmentResourceRequest, options?: RequestInit): Promise<AppointmentResource>;
-export declare function removeAppointmentResourceRequest(apiClient: ApiClient, siteId: string, resourceId: string, options?: RequestInit): Promise<void>;
+export declare function listAppointmentResourcesRequest(apiClient: ApiClient<'listAppointmentResources'>, siteId: string, options?: RequestInit): Promise<AppointmentResource[]>;
+export declare function createAppointmentResourceRequest(apiClient: ApiClient<'createAppointmentResource'>, siteId: string, payload: CreateAppointmentResourceRequest, options?: RequestInit): Promise<AppointmentResource>;
+export declare function updateAppointmentResourceRequest(apiClient: ApiClient<'updateAppointmentResource'>, siteId: string, resourceId: string, payload: UpdateAppointmentResourceRequest, options?: RequestInit): Promise<AppointmentResource>;
+export declare function removeAppointmentResourceRequest(apiClient: ApiClient<'removeAppointmentResource'>, siteId: string, resourceId: string, options?: RequestInit): Promise<void>;

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

@@ -1,13 +1,17 @@
 import type { ApiClient } from "./request";
+/**
+ * Editable route metadata. Lifecycle fields (`draftStatus`, `scheduledPublishAt`,
+ * `status`) aren't here: only the lifecycle operations write them (issue 1553).
+ */
 export type RouteMetadataPayload = {
     draftTitle?: string;
     draftSlug?: string;
-    draftStatus?: "draft" | "scheduled" | "published";
-    scheduledPublishAt?: string | null;
     draftMetaTitle?: string | null;
     draftMetaDescription?: string | null;
     canonicalUrl?: string | null;
     ogImageId?: string | null;
+    /** Managed-editor compare-and-set guard; absent for exempt callers. */
+    expectedDraftUpdatedAt?: string | null;
 };
 export type RouteMetadataResponse = {
     route: {
@@ -17,6 +21,7 @@ export type RouteMetadataResponse = {
         nodeType: "page" | "content_entry" | null;
         draftTitle: string | null;
         draftPath: string | null;
+        draftSlug: string | null;
         draftStatus: string | null;
         publishedTitle: string | null;
         publishedPath: string | null;
@@ -33,7 +38,7 @@ export type RouteMetadataResponse = {
         updatedBy: string | null;
     };
 };
-export declare function updateRouteMetadata(apiClient: ApiClient, { siteId, routeId, body, options, }: {
+export declare function updateRouteMetadata(apiClient: ApiClient<"updateRouteMetadata">, { siteId, routeId, body, options, }: {
     siteId: string;
     routeId: string;
     body: RouteMetadataPayload;

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

@@ -1,3 +1,4 @@
+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';
@@ -23,6 +24,12 @@ export declare const sdkCourseBookingSettingsSchema: z.ZodObject<{
     }>;
     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<{
@@ -125,7 +132,6 @@ type SdkEventRunUpsertCommon = Readonly<{
     categoryRef?: string | null;
     formRef?: string | null;
     settings?: Record<string, unknown>;
-    presentation?: Record<string, unknown> | null;
     tags?: string[];
 }>;
 type SdkEventRunAuthoredScheduleInput = Readonly<{
@@ -156,6 +162,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/sdkBlockUpsertContracts.d.ts

@@ -18,6 +18,7 @@ export type SdkBlockAppearanceOutcome = Readonly<{
 }>;
 export type SdkBlockUpsertResponseFields<TWarning> = Readonly<{
     warnings?: TWarning[];
+    designSyncWarning?: import('./siteRuntimeEndpoints').PageBlockDesignSyncWarning;
     /**
      * Present only when appearance intent was explicit. Validation detected
      * before the block write rejects the request; failures after a durable block
@@ -46,3 +47,23 @@ export declare const sdkBlockAppearanceOutcomeSchema: z.ZodDiscriminatedUnion<[z
     message: z.ZodString;
     retryable: z.ZodLiteral<true>;
 }, z.core.$strip>], "kind">;
+export declare const pageBlockDesignSyncWarningSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        failed: "failed";
+        blocked: "blocked";
+        "skipped-invalid": "skipped-invalid";
+    }>;
+    operation: z.ZodEnum<{
+        update: "update";
+        create: "create";
+        delete: "delete";
+        reorder: "reorder";
+    }>;
+    message: z.ZodString;
+    blocker: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        "published-fallback": "published-fallback";
+    }>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

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

@@ -461,6 +461,9 @@ export interface SdkPullFormField {
     required?: boolean;
     placeholder?: string;
     helpText?: string;
+    layout?: {
+        width?: 'full' | 'half';
+    };
     options?: Array<{
         value: string;
         label: string;
@@ -922,31 +925,7 @@ export type SdkManagementVenue = SdkPullVenue & {
 export type SdkManagementEventCategory = SdkPullEventCategory & {
     id: string;
 };
-export type SdkEventOccurrenceScheduleInput = {
-    startsAt: string;
-    endsAt: string;
-    durationMinutes?: never;
-} | {
-    startsAt: string;
-    endsAt?: never;
-    durationMinutes: number;
-};
-export type SdkAddEventOccurrenceRequest = SdkEventOccurrenceScheduleInput & {
-    capacity?: number;
-};
-export type SdkEventOccurrenceCapacityIntent = {
-    kind: 'override';
-    capacity: number;
-} | {
-    kind: 'inherit';
-};
-export type SdkUpdateEventOccurrenceRequest = {
-    schedule: SdkEventOccurrenceScheduleInput;
-    capacity?: SdkEventOccurrenceCapacityIntent;
-} | {
-    schedule?: never;
-    capacity: SdkEventOccurrenceCapacityIntent;
-};
+export type { SdkAddEventOccurrenceRequest, SdkCancelEventOccurrenceRequest, SdkEventOccurrenceCapacityIntent, SdkEventOccurrenceScheduleInput, SdkUpdateEventOccurrenceRequest, } from './sdkEventOccurrenceRequestContracts';
 export type SdkPageResponse = SdkCommandApplicationResult<SdkManagementPage>;
 export type SdkUpsertPageResponse = SdkPageResponse & SdkPublicationStageFields<SdkPagePublishErrorCode>;
 export interface SdkDraftPage {
@@ -977,9 +956,7 @@ export type SdkUpsertBlockResponse = SdkCommandApplicationResult<SdkManagementBl
 export type SdkDeleteResponse = SdkCommandApplicationResult<Readonly<{
     deleted: true;
 }>>;
-export interface SdkReorderResponse {
-    reordered: true;
-}
+export type SdkReorderResponse = NonNullable<import('./sitePlatformEndpoints').SitePlatformAPIEndpoints['sdkReorderPageBlocks']['response']>;
 /** Closed publish-failure code union for entry upserts. */
 export type SdkEntryPublishErrorCode = 'PUBLISH_ENTRY_FAILED';
 /** Closed publish-failure code union for page upserts. */

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

@@ -2,9 +2,9 @@ import type { z } from 'zod';
 import type { courseBookingSettingsSchema } from '@riverbankcms/site-commands';
 import type { CourseBookingSettingsRequest } from './eventManagementContracts';
 /**
- * The four booking settings a course owns for every one of its runs: where it
- * is listed, whether passes and memberships may be used, and the refunds and
- * transfers policy.
+ * 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
@@ -16,7 +16,7 @@ import type { CourseBookingSettingsRequest } from './eventManagementContracts';
 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 four
+ * 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>;

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

@@ -64,7 +64,7 @@ export declare const SDK_EVENT_ENDPOINT_DEFINITIONS: {
         method: "POST";
         auth: "service";
         responseKind: "json";
-        errors: ("resource:not_found" | "resource:conflict" | "server:internal_error")[];
+        errors: ("validation:invalid_input" | "resource:not_found" | "resource:conflict" | "server:internal_error")[];
     };
     sdkDeleteEventOccurrence: {
         path: "/sdk/{siteId}/events/{identifier}/runs/{runIdentifier}/occurrences/{occurrenceId}";

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

@@ -0,0 +1,43 @@
+/**
+ * Request bodies for the SDK's single-date event endpoints (add, update and
+ * cancel one date of a run). Re-exported from `sdkContracts`.
+ */
+export type SdkEventOccurrenceScheduleInput = {
+    startsAt: string;
+    endsAt: string;
+    durationMinutes?: never;
+} | {
+    startsAt: string;
+    endsAt?: never;
+    durationMinutes: number;
+};
+export type SdkAddEventOccurrenceRequest = SdkEventOccurrenceScheduleInput & {
+    capacity?: number;
+    /**
+     * Course runs only: whether everyone enrolled on the run is emailed about
+     * the new date. Defaults to `true`. Everyone enrolled gets the date either
+     * way. Ignored for ordinary events.
+     */
+    notifyAttendees?: boolean;
+};
+export type SdkCancelEventOccurrenceRequest = {
+    /**
+     * Course runs only: whether everyone enrolled on the run is emailed that
+     * the date was dropped. Defaults to `true`. Their places on the run are
+     * kept either way. Ignored for ordinary events.
+     */
+    notifyAttendees?: boolean;
+};
+export type SdkEventOccurrenceCapacityIntent = {
+    kind: 'override';
+    capacity: number;
+} | {
+    kind: 'inherit';
+};
+export type SdkUpdateEventOccurrenceRequest = {
+    schedule: SdkEventOccurrenceScheduleInput;
+    capacity?: SdkEventOccurrenceCapacityIntent;
+} | {
+    schedule?: never;
+    capacity: SdkEventOccurrenceCapacityIntent;
+};

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

@@ -79,8 +79,10 @@ export interface SdkManagementEventOccurrence {
     confirmedPlaces?: number;
     /**
      * Places held by every row that is not cancelled, so waitlisted and pending
-     * rows are counted too. This is the figure `deletionEligibility` is decided
-     * on: a date with anyone still attached to it cannot be deleted.
+     * rows are counted too. `deletionEligibility` is decided on the records a
+     * delete would lose, which also includes a course run's records of any
+     * status: a dropped course date keeps them so it can be put back, and
+     * cannot be deleted while it does.
      *
      * The name is kept for compatibility with published CLI output. For
      * "how full is this date", read `confirmedPlaces`.

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

@@ -39,7 +39,14 @@ export interface SdkPullEventRun {
     categoryRef: string | null;
     formRef: string | null;
     settings: Record<string, unknown>;
-    presentation: Record<string, unknown> | null;
+    /**
+     * Ignored. Listing words come from the event's own page (`content`). The
+     * current server sends null only because CLIs published before issue 1538
+     * require the key, and servers from before then send a stored object, so
+     * readers accept anything here. It goes once the supported CLI floor passes
+     * that release.
+     */
+    presentation?: unknown;
     tags: string[];
     updatedAt: string;
     createdAt: string;

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

@@ -195,7 +195,7 @@ export type SeoSearchQueriesResponse = {
         pageCount: number;
     }>;
 };
-export declare function applySeoChanges(client: ApiClient, body: ApplySeoChangesRequest): Promise<ApplySeoChangesResponse>;
-export declare function getSeoOverview(apiClient: ApiClient, query: SeoOverviewQuery, options?: RequestInit): Promise<SeoOverviewResponse>;
-export declare function getSeoPages(apiClient: ApiClient, query: SeoSearchPagesQuery, options?: RequestInit): Promise<SeoSearchPagesResponse>;
-export declare function getSeoQueries(apiClient: ApiClient, query: SeoSearchQueriesQuery, options?: RequestInit): Promise<SeoSearchQueriesResponse>;
+export declare function applySeoChanges(client: ApiClient<'applySeoChanges'>, body: ApplySeoChangesRequest): Promise<ApplySeoChangesResponse>;
+export declare function getSeoOverview(apiClient: ApiClient<'getSeoOverview'>, query: SeoOverviewQuery, options?: RequestInit): Promise<SeoOverviewResponse>;
+export declare function getSeoPages(apiClient: ApiClient<'getSeoPages'>, query: SeoSearchPagesQuery, options?: RequestInit): Promise<SeoSearchPagesResponse>;
+export declare function getSeoQueries(apiClient: ApiClient<'getSeoQueries'>, query: SeoSearchQueriesQuery, options?: RequestInit): Promise<SeoSearchQueriesResponse>;

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

@@ -1,6 +1,6 @@
 import type { ApiClient } from './request';
 import type { AppointmentService, CreateAppointmentServiceRequest, UpdateAppointmentServiceRequest } from './types';
-export declare function listAppointmentServicesRequest(apiClient: ApiClient, siteId: string, options?: RequestInit): Promise<AppointmentService[]>;
-export declare function createAppointmentServiceRequest(apiClient: ApiClient, siteId: string, payload: CreateAppointmentServiceRequest, options?: RequestInit): Promise<AppointmentService>;
-export declare function updateAppointmentServiceRequest(apiClient: ApiClient, siteId: string, serviceId: string, payload: UpdateAppointmentServiceRequest, options?: RequestInit): Promise<AppointmentService>;
-export declare function deleteAppointmentServiceRequest(apiClient: ApiClient, siteId: string, serviceId: string, options?: RequestInit): Promise<void>;
+export declare function listAppointmentServicesRequest(apiClient: ApiClient<'listAppointmentServices'>, siteId: string, options?: RequestInit): Promise<AppointmentService[]>;
+export declare function createAppointmentServiceRequest(apiClient: ApiClient<'createAppointmentService'>, siteId: string, payload: CreateAppointmentServiceRequest, options?: RequestInit): Promise<AppointmentService>;
+export declare function updateAppointmentServiceRequest(apiClient: ApiClient<'updateAppointmentService'>, siteId: string, serviceId: string, payload: UpdateAppointmentServiceRequest, options?: RequestInit): Promise<AppointmentService>;
+export declare function deleteAppointmentServiceRequest(apiClient: ApiClient<'deleteAppointmentService'>, siteId: string, serviceId: string, options?: RequestInit): Promise<void>;

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

@@ -0,0 +1,61 @@
+import type { CamelizeKeys, DbRow } from '../../db/src/index';
+import type { APIEndpoint } from './apiEndpointTypes';
+import type { CreateManualSiteRequest, CreateManualSiteResponse } from './siteOperations';
+type Site = CamelizeKeys<DbRow<'sites'>>;
+export type SiteLifecycleAPIEndpoints = {
+    createSite: APIEndpoint<{
+        title: string;
+    }, never, {
+        id: string;
+        title: string;
+    }>;
+    createSiteManual: APIEndpoint<CreateManualSiteRequest, never, CreateManualSiteResponse>;
+    updateSite: APIEndpoint<Partial<Site>, never, Partial<Site>>;
+    deleteSite: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        ok: boolean;
+    }>;
+};
+export declare const SITE_LIFECYCLE_ENDPOINT_DEFINITIONS: {
+    createSite: {
+        path: "/sites/manage";
+        method: "POST";
+        tags: "site"[];
+        auth: "user";
+        responseKind: "json";
+        errors: never[];
+    };
+    createSiteManual: {
+        path: "/sites/manual";
+        method: "POST";
+        tags: "site"[];
+        auth: "user";
+        responseKind: "json";
+        errors: never[];
+    };
+    updateSite: {
+        path: "/sites/manage";
+        method: "PUT";
+        tags: "site"[];
+        auth: "user";
+        responseKind: "json";
+        errors: never[];
+    };
+    deleteSite: {
+        path: "/sites/{siteId}";
+        method: "DELETE";
+        tags: ("site" | "site-{siteId}")[];
+        auth: "user";
+        responseKind: "json";
+        errors: never[];
+        demoMutation: {
+            classification: "allowed";
+            publicMessage: "";
+        } | {
+            classification: import("./apiEndpointTypes").ApiDemoMutationBlockingClassification;
+            publicMessage: string;
+        };
+    };
+};
+export {};