@riverbankcms/sdk 0.145.0 → 0.146.0

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;

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

@@ -0,0 +1,388 @@
+/**
+ * The portable page design document (issue 1497).
+ *
+ * A stored `PageDesignIntent` names blocks by their database ids, so it only
+ * makes sense on the page it came from. The portable document is the same
+ * intent with every block reference expressed as the block's management
+ * identifier (`hero-0`, `body-text-1`), which is what lets a design travel from
+ * one page to another page built from the same blocks.
+ *
+ * A boundary is carried as its identifier pair only. Its stored `boundaryId`
+ * is derived from the pair after mapping, so the two can never disagree.
+ *
+ * The document is parsed once, here, at the JSON boundary. Whether it fits a
+ * particular destination page is a separate, semantic decision made by the
+ * dashboard against that page's blocks and site style.
+ */
+import { z } from 'zod';
+import type { Brand } from '../../core/src/index';
+import { pageDesignIntentSchemaVersion, type AppearancePresetId, type PageDesignUserPinnedChoice, type PageFlowPresetId, type SectionBoundaryTreatment, type SiteStyleId } from '../../theme-core/src/site-styles/index';
+import type { APIEndpoint } from './apiEndpointTypes';
+import type { PageDesignRevisionToken } from './siteRuntimeEndpoints';
+/** A block's management identifier, as a page's blocks carry it. */
+export type BlockIdentifier = Brand<string, 'BlockIdentifier'>;
+export declare const unsafeAsBlockIdentifier: (value: string) => BlockIdentifier;
+export type PortableBlockLookPin = Readonly<{
+    blockIdentifier: BlockIdentifier;
+    blockKind: string;
+    choice: PageDesignUserPinnedChoice<AppearancePresetId>;
+}>;
+export type PortableBoundaryPin = Readonly<{
+    previousBlockIdentifier: BlockIdentifier;
+    nextBlockIdentifier: BlockIdentifier;
+    choice: PageDesignUserPinnedChoice<SectionBoundaryTreatment>;
+}>;
+/** `PageDesignIntent`, keyed by block identifier instead of block id. */
+export type PortablePageDesign = Readonly<{
+    schemaVersion: typeof pageDesignIntentSchemaVersion;
+    siteStyleId: SiteStyleId;
+    pageFlowPresetId: PageFlowPresetId;
+    blockLookPins: readonly PortableBlockLookPin[];
+    boundaryPins: readonly PortableBoundaryPin[];
+}>;
+/**
+ * A stored pin the portable document could not carry because it names a block
+ * that is no longer on the page. Such pins have no effect in the editor or on
+ * the rendered page; they are reported so nothing is dropped silently.
+ */
+export type OmittedPagePin = Readonly<{
+    kind: 'look-on-missing-block';
+    blockId: string;
+}> | Readonly<{
+    kind: 'boundary-on-missing-block';
+    previousBlockId: string;
+    nextBlockId: string;
+}>;
+/**
+ * Where a stored design was read from. A page with a draft design reads the
+ * draft; a page without one reads its latest published design (decision D9).
+ */
+export type PageDesignStoredSource = 'draft' | 'published';
+/**
+ * A page's stored design. `absent` means nothing was ever saved for the page;
+ * its site style's defaults are never exported as authored intent.
+ */
+export type SdkGetPageDesignResponse = Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'stored';
+    source: PageDesignStoredSource;
+    design: PortablePageDesign;
+    revision: PageDesignRevisionToken;
+    omitted: readonly OmittedPagePin[];
+}>;
+export type SdkSavePageDesignBody = Readonly<{
+    design: PortablePageDesign;
+    expectedRevision: PageDesignRevisionToken;
+}>;
+export type SdkSavePageDesignResponse = Readonly<{
+    outcome: 'created' | 'updated';
+    revision: PageDesignRevisionToken;
+}>;
+export type SdkPageDesignAPIEndpoints = {
+    sdkGetPageDesign: APIEndpoint<never, {
+        siteId: string;
+        identifier: string;
+    }, SdkGetPageDesignResponse>;
+    sdkSavePageDesign: APIEndpoint<SdkSavePageDesignBody, {
+        siteId: string;
+        identifier: string;
+    }, SdkSavePageDesignResponse>;
+};
+export declare const portablePageDesignSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    siteStyleId: z.ZodPipe<z.ZodString, z.ZodTransform<SiteStyleId, string>>;
+    pageFlowPresetId: z.ZodPipe<z.ZodString, z.ZodTransform<PageFlowPresetId, string>>;
+    blockLookPins: z.ZodArray<z.ZodObject<{
+        blockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+        blockKind: z.ZodString;
+        choice: z.ZodObject<{
+            kind: z.ZodLiteral<"user-pinned">;
+            value: z.ZodPipe<z.ZodString, z.ZodTransform<AppearancePresetId, string>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    boundaryPins: z.ZodArray<z.ZodObject<{
+        previousBlockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+        nextBlockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+        choice: z.ZodObject<{
+            kind: z.ZodLiteral<"user-pinned">;
+            value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"none">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"soft-fade">;
+                height: z.ZodEnum<{
+                    medium: "medium";
+                    compact: "compact";
+                    large: "large";
+                    expansive: "expansive";
+                }>;
+                curve: z.ZodEnum<{
+                    soft: "soft";
+                    spacious: "spacious";
+                    expansive: "expansive";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"wave-edge">;
+                height: z.ZodEnum<{
+                    medium: "medium";
+                    compact: "compact";
+                    large: "large";
+                }>;
+                amplitude: z.ZodEnum<{
+                    bold: "bold";
+                    subtle: "subtle";
+                    balanced: "balanced";
+                }>;
+                rhythm: z.ZodEnum<{
+                    single: "single";
+                    double: "double";
+                }>;
+                symmetry: z.ZodEnum<{
+                    drift: "drift";
+                    symmetrical: "symmetrical";
+                    asymmetrical: "asymmetrical";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"angle-edge">;
+                height: z.ZodEnum<{
+                    medium: "medium";
+                    compact: "compact";
+                    large: "large";
+                }>;
+                slope: z.ZodEnum<{
+                    subtle: "subtle";
+                    balanced: "balanced";
+                    steep: "steep";
+                }>;
+                direction: z.ZodEnum<{
+                    reverse: "reverse";
+                    forward: "forward";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"legacy-unsupported">;
+                boundaryOptionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../blocks/src/index").BoundaryOptionId, string>>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const pageDesignRevisionTokenSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"absent">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"draft">;
+    contentVersionId: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"published">;
+    contentVersionId: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const sdkSavePageDesignBodySchema: z.ZodObject<{
+    design: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        siteStyleId: z.ZodPipe<z.ZodString, z.ZodTransform<SiteStyleId, string>>;
+        pageFlowPresetId: z.ZodPipe<z.ZodString, z.ZodTransform<PageFlowPresetId, string>>;
+        blockLookPins: z.ZodArray<z.ZodObject<{
+            blockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+            blockKind: z.ZodString;
+            choice: z.ZodObject<{
+                kind: z.ZodLiteral<"user-pinned">;
+                value: z.ZodPipe<z.ZodString, z.ZodTransform<AppearancePresetId, string>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        boundaryPins: z.ZodArray<z.ZodObject<{
+            previousBlockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+            nextBlockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+            choice: z.ZodObject<{
+                kind: z.ZodLiteral<"user-pinned">;
+                value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"none">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"soft-fade">;
+                    height: z.ZodEnum<{
+                        medium: "medium";
+                        compact: "compact";
+                        large: "large";
+                        expansive: "expansive";
+                    }>;
+                    curve: z.ZodEnum<{
+                        soft: "soft";
+                        spacious: "spacious";
+                        expansive: "expansive";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"wave-edge">;
+                    height: z.ZodEnum<{
+                        medium: "medium";
+                        compact: "compact";
+                        large: "large";
+                    }>;
+                    amplitude: z.ZodEnum<{
+                        bold: "bold";
+                        subtle: "subtle";
+                        balanced: "balanced";
+                    }>;
+                    rhythm: z.ZodEnum<{
+                        single: "single";
+                        double: "double";
+                    }>;
+                    symmetry: z.ZodEnum<{
+                        drift: "drift";
+                        symmetrical: "symmetrical";
+                        asymmetrical: "asymmetrical";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"angle-edge">;
+                    height: z.ZodEnum<{
+                        medium: "medium";
+                        compact: "compact";
+                        large: "large";
+                    }>;
+                    slope: z.ZodEnum<{
+                        subtle: "subtle";
+                        balanced: "balanced";
+                        steep: "steep";
+                    }>;
+                    direction: z.ZodEnum<{
+                        reverse: "reverse";
+                        forward: "forward";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"legacy-unsupported">;
+                    boundaryOptionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../blocks/src/index").BoundaryOptionId, string>>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    expectedRevision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"draft">;
+        contentVersionId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"published">;
+        contentVersionId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const sdkGetPageDesignResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"absent">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"stored">;
+    source: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+    }>;
+    design: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        siteStyleId: z.ZodPipe<z.ZodString, z.ZodTransform<SiteStyleId, string>>;
+        pageFlowPresetId: z.ZodPipe<z.ZodString, z.ZodTransform<PageFlowPresetId, string>>;
+        blockLookPins: z.ZodArray<z.ZodObject<{
+            blockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+            blockKind: z.ZodString;
+            choice: z.ZodObject<{
+                kind: z.ZodLiteral<"user-pinned">;
+                value: z.ZodPipe<z.ZodString, z.ZodTransform<AppearancePresetId, string>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        boundaryPins: z.ZodArray<z.ZodObject<{
+            previousBlockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+            nextBlockIdentifier: z.ZodPipe<z.ZodString, z.ZodTransform<BlockIdentifier, string>>;
+            choice: z.ZodObject<{
+                kind: z.ZodLiteral<"user-pinned">;
+                value: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"none">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"soft-fade">;
+                    height: z.ZodEnum<{
+                        medium: "medium";
+                        compact: "compact";
+                        large: "large";
+                        expansive: "expansive";
+                    }>;
+                    curve: z.ZodEnum<{
+                        soft: "soft";
+                        spacious: "spacious";
+                        expansive: "expansive";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"wave-edge">;
+                    height: z.ZodEnum<{
+                        medium: "medium";
+                        compact: "compact";
+                        large: "large";
+                    }>;
+                    amplitude: z.ZodEnum<{
+                        bold: "bold";
+                        subtle: "subtle";
+                        balanced: "balanced";
+                    }>;
+                    rhythm: z.ZodEnum<{
+                        single: "single";
+                        double: "double";
+                    }>;
+                    symmetry: z.ZodEnum<{
+                        drift: "drift";
+                        symmetrical: "symmetrical";
+                        asymmetrical: "asymmetrical";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"angle-edge">;
+                    height: z.ZodEnum<{
+                        medium: "medium";
+                        compact: "compact";
+                        large: "large";
+                    }>;
+                    slope: z.ZodEnum<{
+                        subtle: "subtle";
+                        balanced: "balanced";
+                        steep: "steep";
+                    }>;
+                    direction: z.ZodEnum<{
+                        reverse: "reverse";
+                        forward: "forward";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"legacy-unsupported">;
+                    boundaryOptionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../blocks/src/index").BoundaryOptionId, string>>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    revision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"draft">;
+        contentVersionId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"published">;
+        contentVersionId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    omitted: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"look-on-missing-block">;
+        blockId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"boundary-on-missing-block">;
+        previousBlockId: z.ZodString;
+        nextBlockId: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>], "kind">;
+export declare const sdkSavePageDesignResponseSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        updated: "updated";
+        created: "created";
+    }>;
+    revision: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"absent">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"draft">;
+        contentVersionId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"published">;
+        contentVersionId: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strip>;

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

@@ -0,0 +1,22 @@
+/**
+ * SDK management endpoints for a page's draft design (issue 1497), spread into
+ * `ENDPOINT_DEFINITIONS` like the other endpoint-definition modules. New
+ * entries here must declare `errors`, which the require-api-endpoint-errors
+ * lint enforces.
+ */
+export declare const SDK_PAGE_DESIGN_ENDPOINT_DEFINITIONS: {
+    sdkGetPageDesign: {
+        path: "/sdk/{siteId}/pages/{identifier}/design";
+        method: "GET";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "server:internal_error")[];
+    };
+    sdkSavePageDesign: {
+        path: "/sdk/{siteId}/pages/{identifier}/design";
+        method: "POST";
+        auth: "service";
+        responseKind: "json";
+        errors: ("validation:invalid_input" | "resource:not_found" | "resource:conflict" | "server:internal_error")[];
+    };
+};

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

@@ -0,0 +1,46 @@
+import type { EventPreset, RichTextDoc } from '../../core/src/index';
+import type { SdkEventBookingOffer, SdkEntrySlotBlocks } from './sdkContracts';
+import type { SdkPullEventOccurrence } from './sdk-event-schedule';
+import type { SdkPulledCourseBooking } from './sdkCourseBooking';
+/** A course also carries `courseBooking`; see `SdkPulledCourseBooking`. */
+export interface SdkPullEvent extends SdkPulledCourseBooking {
+    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';
+    /** Absent on a run of a course: listing is the course's (`courseBooking`). */
+    visibility?: '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;
+}

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

@@ -0,0 +1,29 @@
+import type { APIEndpoint } from './apiEndpointTypes';
+/**
+ * A site's managed address can change until it goes live. Refusals arrive as
+ * an error envelope whose `fieldErrors[0]` has `field: 'slug'` and one of
+ * these codes: 409 `address_taken` | `already_live`, 422 `reserved` |
+ * `invalid_format`.
+ */
+export type SiteAddressChangeRefusalCode = 'address_taken' | 'already_live' | 'reserved' | 'invalid_format';
+export type ChangeSiteAddressRequest = {
+    slug: string;
+};
+export type ChangeSiteAddressResponse = {
+    kind: 'changed' | 'unchanged';
+    slug: string;
+};
+/** `slug` is the checked value after trimming and lower-casing. */
+export type SiteAddressAvailabilityResponse = {
+    kind: 'available' | 'taken' | 'reserved' | 'invalid_format';
+    slug: string;
+};
+export type SiteAddressAPIEndpoints = {
+    changeSiteAddress: APIEndpoint<ChangeSiteAddressRequest, {
+        siteId: string;
+    }, ChangeSiteAddressResponse>;
+    getSiteAddressAvailability: APIEndpoint<never, {
+        siteId: string;
+        slug: string;
+    }, SiteAddressAvailabilityResponse>;
+};

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

@@ -0,0 +1,49 @@
+export declare const SITE_MANAGEMENT_ENDPOINT_DEFINITIONS: {
+    createSite: {
+        path: "/sites/manage";
+        method: "POST";
+        tags: "site"[];
+        auth: "user";
+        responseKind: "json";
+    };
+    updateSite: {
+        path: "/sites/manage";
+        method: "PUT";
+        tags: "site"[];
+        auth: "user";
+        responseKind: "json";
+    };
+    changeSiteAddress: {
+        path: "/sites/{siteId}/address";
+        method: "PUT";
+        auth: "user";
+        responseKind: "json";
+        demoMutation: {
+            classification: "allowed";
+            publicMessage: "";
+        } | {
+            classification: import("./apiEndpointTypes").ApiDemoMutationBlockingClassification;
+            publicMessage: string;
+        };
+    };
+    getSiteAddressAvailability: {
+        path: "/sites/{siteId}/address/availability";
+        method: "GET";
+        auth: "user";
+        responseKind: "json";
+    };
+    deleteSite: {
+        path: "/sites/{siteId}";
+        method: "DELETE";
+        tags: ("site" | "site-{siteId}")[];
+        auth: "user";
+        responseKind: "json";
+        demoMutation: {
+            classification: "allowed";
+            publicMessage: "";
+        } | {
+            classification: import("./apiEndpointTypes").ApiDemoMutationBlockingClassification;
+            publicMessage: string;
+        };
+    };
+};

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

@@ -14,8 +14,7 @@ import type { GetVersionHistoryResponse, ListVersionHistoryResponse, RestoreVers
 import type { ApplyContentTemplateAddonRequest, ContentTemplateDetailsResponse, CreateTemplateBlockRequest, GetTransformsResponse, ReorderTemplateBlocksRequest, SerializedContentTypeSummary, UpdateContentTemplateBlockBindingsRequest, UpdateContentTemplateBlockRequest } from './contentTypes';
 import type { LinkPayload, RoutableContentItem, SitemapRouteItem } from './navigation/types';
 import type { RouteMetadataPayload, RouteMetadataResponse } from './routes';
-import type { PageSurfaceEditorDocument, PublishPageSurfaceResponse } from './contentRuntime';
-import type { ContentRouteRecord } from './types';
+import type { PageSurfaceAPIEndpoints } from './pageSurfaceEndpoints';
 import type { SiteAnalyticsSettingsPayload, SiteAnalyticsSettingsResponse } from './siteAnalytics';
 import type { SiteBannerSettingsPayload, SiteBannerSettingsResponse } from './siteBanner';
 import type { GeneratedIconSetGenerateRequest, GeneratedIconSetGenerateResponse, GeneratedIconSetListRequest, GeneratedIconSetListResponse, SiteIconStyleGuideResponse, SiteIconStyleGuideUpdateRequest } from './siteIcons';
@@ -146,7 +145,7 @@ type DsarExecutionOutcomeApi = {
     detail: string;
     message: string;
 };
-export type SiteManagementAPIEndpoints = BillingAPIEndpoints & {
+export type SiteManagementAPIEndpoints = BillingAPIEndpoints & PageSurfaceAPIEndpoints & {
     createSite: APIEndpoint<{
         title: string;
     }, never, {
@@ -247,35 +246,6 @@ export type SiteManagementAPIEndpoints = BillingAPIEndpoints & {
         type: string;
         entryId: string;
     }, ContentEntryOrPageResponse>;
-    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>;
     runSdkWorkflow: APIEndpoint<never, {
         siteId: string;
         type: string;