@riverbankcms/sdk 0.144.0 → 0.146.0

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

@@ -22,6 +22,19 @@ export type PublicNewsletterAPIEndpoints = {
         siteId: string;
         token: string;
     }, string>;
+    confirmNewsletterPost: APIEndpoint<never, {
+        siteId: string;
+        token: string;
+    }, string>;
+    getNewsletterPreferences: APIEndpoint<never, {
+        siteId: string;
+        token: string;
+        unsubscribe?: string;
+    }, string>;
+    saveNewsletterPreferences: APIEndpoint<FormData, {
+        siteId: string;
+        token: string;
+    }, string>;
     getNewsletterArchive: APIEndpoint<never, {
         siteId: string;
         token: string;

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

@@ -0,0 +1,58 @@
+export declare const PUBLIC_NEWSLETTER_ENDPOINT_DEFINITIONS: {
+    subscribeNewsletter: {
+        path: "/public/sites/{siteId}/newsletter/subscribe";
+        method: "POST";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "json";
+    };
+    confirmNewsletter: {
+        path: "/public/sites/{siteId}/newsletter/confirm/{token}";
+        method: "GET";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+    unsubscribeNewsletter: {
+        path: "/public/sites/{siteId}/newsletter/unsubscribe/{token}";
+        method: "GET";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+    unsubscribeNewsletterPost: {
+        path: "/public/sites/{siteId}/newsletter/unsubscribe/{token}";
+        method: "POST";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+    confirmNewsletterPost: {
+        path: "/public/sites/{siteId}/newsletter/confirm/{token}";
+        method: "POST";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+    getNewsletterPreferences: {
+        path: "/public/sites/{siteId}/newsletter/preferences/{token}";
+        method: "GET";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+    saveNewsletterPreferences: {
+        path: "/public/sites/{siteId}/newsletter/preferences/{token}";
+        method: "POST";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+    getNewsletterArchive: {
+        path: "/public/sites/{siteId}/newsletter/archive/{token}";
+        method: "GET";
+        tags: "public-newsletter-{siteId}"[];
+        auth: "public";
+        responseKind: "text";
+    };
+};

package/dist/_dts/api/src/schemas/admin-observability-logs.d.ts

@@ -8,8 +8,8 @@ export declare const adminListAxiomLogsQuerySchema: z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
     tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        errors: "errors";
         all: "all";
+        errors: "errors";
         warnings: "warnings";
     }>>;
 }, z.core.$strip>;
@@ -40,8 +40,8 @@ export declare const adminListSupabaseLogsQuerySchema: z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
     tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        errors: "errors";
         all: "all";
+        errors: "errors";
         warnings: "warnings";
     }>>;
 }, z.core.$strip>;
@@ -53,8 +53,8 @@ export declare const adminListVercelLogsQuerySchema: z.ZodObject<{
     search: z.ZodOptional<z.ZodString>;
     tail: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        errors: "errors";
         all: "all";
+        errors: "errors";
         warnings: "warnings";
     }>>;
 }, z.core.$strip>;

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

@@ -1,3 +1,4 @@
+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 +11,39 @@ 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;
+    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 +54,6 @@ export declare const sdkEventUpsertOptionalFieldSchemas: {
         cancelled: "cancelled";
     }>>;
     readonly visibility: z.ZodOptional<z.ZodEnum<{
-        private: "private";
         public: "public";
         unlisted: "unlisted";
     }>>;
@@ -108,6 +141,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;

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 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.
+ *
+ * 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 four
+ * 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;