@riverbankcms/sdk 0.147.0 → 0.149.0

package/dist/_dts/api/src/common/cancellation.d.ts

@@ -6,3 +6,26 @@ export type StaffCancellationContextInput = Readonly<{
     category: StaffCancellationContextUiCategory;
     internalNote?: string | null;
 }>;
+export type AdminBookingReturnableValue = {
+    kind: 'money';
+    remainingRefundableCents: number;
+    currency: string | null;
+} | {
+    kind: 'credit';
+    creditsToRestore: number;
+};
+export type AdminBookingCancellationPreview = {
+    canCancel: boolean;
+    defaultRefund: 'no_refund';
+    canOverrideRefund: boolean;
+    refundCutoffAt: string | null;
+    returnable: {
+        kind: 'none';
+    };
+} | {
+    canCancel: true;
+    defaultRefund: 'refund' | 'no_refund';
+    canOverrideRefund: boolean;
+    refundCutoffAt: string | null;
+    returnable: AdminBookingReturnableValue;
+};

package/dist/_dts/api/src/common/envelope.d.ts

@@ -24,8 +24,8 @@ export interface ApiResponse<TData> {
     data: TData;
     meta: ResponseMeta;
 }
-export type ApiErrorCode = 'auth:unauthenticated' | 'auth:token_expired' | 'auth:token_invalid' | 'auth:forbidden' | 'auth:mfa_required' | 'auth:sudo_required' | 'auth:insufficient_permissions' | 'auth:impersonation_restricted' | 'validation:invalid_input' | 'validation:missing_field' | 'validation:invalid_format' | 'validation:payload_too_large' | 'resource:not_found' | 'resource:already_exists' | 'resource:conflict' | 'resource:gone' | 'rate_limit:exceeded' | 'billing:payment_required' | 'billing:plan_limit_exceeded' | 'billing:pass_redemption_failed' | 'server:internal_error' | 'server:unavailable' | 'external:service_error' | 'external:registrar_orphaned_contact_profile' | 'network:connection_error' | 'network:timeout' | 'network:dns_error';
-export declare const API_ERROR_CODES: readonly ["auth:unauthenticated", "auth:token_expired", "auth:token_invalid", "auth:forbidden", "auth:mfa_required", "auth:sudo_required", "auth:insufficient_permissions", "auth:impersonation_restricted", "validation:invalid_input", "validation:missing_field", "validation:invalid_format", "validation:payload_too_large", "resource:not_found", "resource:already_exists", "resource:conflict", "resource:gone", "rate_limit:exceeded", "billing:payment_required", "billing:plan_limit_exceeded", "billing:pass_redemption_failed", "server:internal_error", "server:unavailable", "external:service_error", "external:registrar_orphaned_contact_profile", "network:connection_error", "network:timeout", "network:dns_error"];
+export type ApiErrorCode = 'auth:unauthenticated' | 'auth:token_expired' | 'auth:token_invalid' | 'auth:forbidden' | 'auth:mfa_required' | 'auth:sudo_required' | 'auth:insufficient_permissions' | 'auth:impersonation_restricted' | 'auth:lease_required' | 'auth:lease_lost' | 'validation:invalid_input' | 'validation:missing_field' | 'validation:invalid_format' | 'validation:payload_too_large' | 'resource:not_found' | 'resource:already_exists' | 'resource:conflict' | 'resource:gone' | 'rate_limit:exceeded' | 'billing:payment_required' | 'billing:plan_limit_exceeded' | 'billing:pass_redemption_failed' | 'server:internal_error' | 'server:unavailable' | 'external:service_error' | 'external:registrar_orphaned_contact_profile' | 'network:connection_error' | 'network:timeout' | 'network:dns_error';
+export declare const API_ERROR_CODES: readonly ["auth:unauthenticated", "auth:token_expired", "auth:token_invalid", "auth:forbidden", "auth:mfa_required", "auth:sudo_required", "auth:insufficient_permissions", "auth:impersonation_restricted", "auth:lease_required", "auth:lease_lost", "validation:invalid_input", "validation:missing_field", "validation:invalid_format", "validation:payload_too_large", "resource:not_found", "resource:already_exists", "resource:conflict", "resource:gone", "rate_limit:exceeded", "billing:payment_required", "billing:plan_limit_exceeded", "billing:pass_redemption_failed", "server:internal_error", "server:unavailable", "external:service_error", "external:registrar_orphaned_contact_profile", "network:connection_error", "network:timeout", "network:dns_error"];
 export declare function isApiErrorCode(value: unknown): value is ApiErrorCode;
 export interface FieldError {
     field: string;

package/dist/_dts/api/src/content-editor.d.ts

@@ -1,5 +1,5 @@
 export { createContentEntry, discardContentDraft, deleteContentEntry, publishContentEntry, scheduleContentEntry, cancelScheduledContentEntry, updateContentEntryContent, type ContentTypeKey, } from "./contentEntries";
 export { updateRouteMetadata, type RouteMetadataPayload } from "./routes";
 export type { ApiClient } from "./request";
-export type { ContentEntryDetail, PageRecord, WorkflowPageDraftContent, WorkflowPagePublishedContent, WorkflowPageStatus, } from "./contentRuntime";
-export type { JsonValue, PublishedBlockBaseline } from "./types";
+export type { ContentEntryDetail, DocumentBlockState, DocumentBlockBaseline, ContentRouteRecord, EntryContentWriteResult, PageSurfaceEditorDocument, PageSurfaceContentSlotsResponse, PublishPageSurfaceResponse, PageRecord, WorkflowPageDraftContent, WorkflowPagePublishedContent, WorkflowPageStatus, } from "./contentRuntime";
+export type { JsonValue } from "./types";

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

@@ -1,49 +1,45 @@
-import type { ContentEntryListStage, ListPublishedEntriesResponse, ContentEntryDetailResponse } from "./types";
+import type { ContentEntryListStage, ListPublishedEntriesResponse, APIEndpoints } from "./types";
 import type { ApiClient } from "./request";
-import type { ScheduledContentEntryOrPageResponse } from "./contentRuntime";
+import type { PublishContentEntryBody, PublishedContentEntryOrPageResponse, DiscardedContentEntryOrPageResponse, ScheduledPublishingRouteResponse } from "./contentRuntime";
 export { contentKeys } from "./contentKeys";
-export type { ContentEntryDetail, ContentEntryListItem, ContentEntrySummary, JsonValue, PublishedBlockBaseline, } from "./types";
+export type { ContentEntryDetail, ContentEntryListItem, ContentEntrySummary, JsonValue, DocumentBlockState, DocumentBlockBaseline, EntryPageContentSlotsResponse, } from "./types";
 type JsonValue = import("./types").JsonValue;
 export type ContentTypeKey = string;
 export declare function createContentEntry<TResponse extends {
     entry: unknown;
-}>(apiClient: ApiClient, { type, siteId, body, options, }: {
+}>(apiClient: ApiClient<"createContentEntry">, { type, siteId, body, options, }: {
     type: ContentTypeKey;
     siteId: string;
     body?: Record<string, JsonValue>;
     options?: RequestInit;
 }): Promise<TResponse>;
-export declare function publishContentEntry<TRequest extends Record<string, JsonValue> | undefined, TResponse extends {
-    entry: unknown;
-}>(apiClient: ApiClient, { type, siteId, entryId, body, options, }: {
+export declare function publishContentEntry(apiClient: ApiClient<"publishContentEntry">, { type, siteId, entryId, body, options, }: {
     type: ContentTypeKey;
     siteId: string;
     entryId: string;
-    body?: TRequest;
+    body?: PublishContentEntryBody;
     options?: RequestInit;
-}): Promise<TResponse>;
-export declare function scheduleContentEntry(apiClient: ApiClient, { type, siteId, entryId, publishAt, options, }: {
+}): Promise<PublishedContentEntryOrPageResponse>;
+export declare function scheduleContentEntry(apiClient: ApiClient<"scheduleContentEntry">, { type, siteId, entryId, publishAt, options, }: {
     type: ContentTypeKey;
     siteId: string;
     entryId: string;
     publishAt: string;
     options?: RequestInit;
-}): Promise<ScheduledContentEntryOrPageResponse>;
-export declare function cancelScheduledContentEntry(apiClient: ApiClient, { type, siteId, entryId, options, }: {
+}): Promise<ScheduledPublishingRouteResponse>;
+export declare function cancelScheduledContentEntry(apiClient: ApiClient<"cancelScheduledContentEntry">, { type, siteId, entryId, options, }: {
     type: ContentTypeKey;
     siteId: string;
     entryId: string;
     options?: RequestInit;
-}): Promise<ScheduledContentEntryOrPageResponse>;
-export declare function discardContentDraft<TResponse extends {
-    entry: unknown;
-}>(apiClient: ApiClient, { type, siteId, entryId, options, }: {
+}): Promise<ScheduledPublishingRouteResponse>;
+export declare function discardContentDraft(apiClient: ApiClient<"discardContentEntry">, { type, siteId, entryId, options, }: {
     type: ContentTypeKey;
     siteId: string;
     entryId: string;
     options?: RequestInit;
-}): Promise<TResponse>;
-export declare function deleteContentEntry(apiClient: ApiClient, { type, siteId, entryId, options, }: {
+}): Promise<DiscardedContentEntryOrPageResponse>;
+export declare function deleteContentEntry(apiClient: ApiClient<"deleteContentEntry">, { type, siteId, entryId, options, }: {
     type: ContentTypeKey;
     siteId: string;
     entryId: string;
@@ -51,9 +47,7 @@ export declare function deleteContentEntry(apiClient: ApiClient, { type, siteId,
 }): Promise<{
     ok: boolean;
 }>;
-export declare function updateContentEntryContent<TResponse extends {
-    entry: unknown;
-}>(apiClient: ApiClient, { siteId, type, entryId, body, options, }: {
+export declare function updateContentEntryContent(apiClient: ApiClient<"updateContentEntryContent">, { siteId, type, entryId, body, options, }: {
     siteId: string;
     type: ContentTypeKey;
     entryId: string;
@@ -66,33 +60,8 @@ export declare function updateContentEntryContent<TResponse extends {
         optimistic_hash?: string | null;
     };
     options?: RequestInit;
-}): Promise<TResponse>;
-type ContentEntryMetadataInput = {
-    title?: string | null;
-    slug?: string | null;
-    status?: "draft" | "scheduled" | "published";
-    publishAt?: string | null;
-    metaTitle?: string | null;
-    metaDescription?: string | null;
-    ogImageId?: string | null;
-};
-type ContentEntryContentInput = {
-    data: Record<string, JsonValue>;
-    optimistic_hash?: string | null;
-} | {
-    path: string;
-    value: JsonValue;
-    optimistic_hash?: string | null;
-};
-export declare function mutateContentEntryUnified<TContent = Record<string, unknown>>(apiClient: ApiClient, { siteId, type, entryId, metadata, content, options, }: {
-    siteId: string;
-    type: ContentTypeKey;
-    entryId: string;
-    metadata?: ContentEntryMetadataInput;
-    content?: ContentEntryContentInput;
-    options?: RequestInit;
-}): Promise<ContentEntryDetailResponse<TContent>>;
-export declare function listPublishedEntries<TContent = Record<string, unknown>>(apiClient: ApiClient, { siteId, type, limit, offset, order, stage, meta, mode, entryIds, options, }: {
+}): Promise<NonNullable<APIEndpoints["updateContentEntryContent"]["response"]>>;
+export declare function listPublishedEntries<TContent = Record<string, unknown>>(apiClient: ApiClient<"listPublishedEntries">, { siteId, type, limit, offset, order, stage, meta, mode, entryIds, options, }: {
     siteId: string;
     type: string;
     limit?: number;

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

@@ -1,7 +1,10 @@
+import type { DocumentBlockState } from './documentLifecycle';
+export type { DocumentBlockState, DocumentBlockBaseline, DiscardPageSurfaceResponse, PublishPageSurfaceResponse } from './documentLifecycle';
 import type { Block, SdkCustomBlock, SdkCustomBlockInput, SiteFont, Theme } from '../../blocks/src/index';
 import type { CamelizeKeys, DbRow } from '../../db/src/index';
 import type { ContentTypeRoutingInfo, PublicContentTypeMeta } from './contentTypes';
 import type { SiteRuntimePrivacyPolicy } from './privacyPolicy';
+import type { SdkRuntimeEntry, SdkEditorRevision } from './siteRuntimeEntry';
 import type { SitePagePayload } from './sitePages';
 import type { RiverbankSiteConfig } from './sdkContracts';
 import type { SdkBlockContentAdmission } from './sdkBlockContentAdmission';
@@ -105,6 +108,8 @@ export type ContentEntryDetail<TContent> = {
     route: ContentRouteRecord | null;
     draftContent: TContent;
     publishedContent: TContent | null;
+    /** Baseline hash when this detail is projected for an interactive editor. */
+    optimisticHash?: string;
 };
 export type PageSurfaceEditorDocument<TContent = Record<string, unknown>> = {
     owner: {
@@ -116,8 +121,24 @@ export type PageSurfaceEditorDocument<TContent = Record<string, unknown>> = {
     publishedContent: TContent | null;
     optimisticHash: string;
 };
-export type PublishPageSurfaceResponse = {
-    publication: 'published' | 'noChange';
+export type ContentEntryEditorDetail<TContent = Record<string, unknown>> = ContentEntryDetail<TContent> & Readonly<{
+    optimisticHash: string;
+}>;
+/**
+ * What an entry lifecycle write did to the entry's draft content. `written` carries
+ * the content now effective and `hash`, the token the next content save
+ * compare-and-sets against. `unchanged` wrote no content: the editor keeps its own.
+ */
+export type EntryContentWriteResult = {
+    kind: 'written';
+    values: Record<string, unknown>;
+    hash: string;
+} | {
+    kind: 'unchanged';
+};
+/** Schedule and cancel return the route row their own UPDATE wrote. */
+export type ScheduledPublishingRouteResponse = {
+    route: ContentRouteRecord;
 };
 export type ContentEntryDetailResponse<TContent = Record<string, unknown>> = {
     entry: ContentEntryDetail<TContent>;
@@ -319,6 +340,8 @@ export type NavigationMenuWithItems = NavigationMenuRecord & {
     items: NavigationItemRecord[];
 };
 export type SiteBySlugResponse = {
+    /** True when demo booking confirmations are suppressed because no claim is active. */
+    demoEmailSuppressed?: boolean;
     site: {
         id: string;
         title: string;
@@ -437,6 +460,7 @@ export type EntryPageContentSlot = Readonly<{
     label: string;
     allowedBlocks: EntryPageContentSlotAllowedBlocks;
     blocks: readonly BlockListItem[];
+    publishedBlockIds: readonly string[];
 }>;
 export type PageSurfaceContentSlot = Omit<EntryPageContentSlot, 'blocks'> & Readonly<{
     compositionHash: string;
@@ -455,23 +479,34 @@ export type PageSurfaceContentSlotsResponse = Readonly<{
     slots: readonly PageSurfaceContentSlot[];
     warnings: readonly EntryPageContentSlotWarning[];
 }>;
-export type PublishedBlockBaseline = {
-    id: string;
-    kind: string;
-    publishedContent: Record<string, unknown> | null;
-};
 export type ContentEntryOrPageResponse<TContent = Record<string, unknown>> = ContentEntryDetailResponse<TContent> | {
     entry: PageRecord;
 };
-export type ScheduledContentEntryOrPageResponse<TContent = Record<string, unknown>> = ({
-    kind: 'content';
-} & ContentEntryDetailResponse<TContent>) | {
-    kind: 'page';
+/** Publish request body. Publishing is immediate; scheduling is the schedule endpoint's (issue 1553). */
+export type PublishContentEntryBody = Readonly<{
+    content?: Record<string, import('./shared-contracts').JsonValue>;
+}>;
+export type PublishedContentEntryOrPageResponse<TContent = Record<string, unknown>> = (ContentEntryDetailResponse<TContent> & {
+    content: EntryContentWriteResult;
+    blockState: Extract<DocumentBlockState, {
+        kind: 'entry-slots';
+    }>;
+}) | {
     entry: PageRecord;
+    blockState: Extract<DocumentBlockState, {
+        kind: 'page';
+    }>;
 };
-export type PublishedContentEntryOrPageResponse<TContent = Record<string, unknown>> = ContentEntryDetailResponse<TContent> | {
+export type DiscardedContentEntryOrPageResponse<TContent = Record<string, unknown>> = (ContentEntryDetailResponse<TContent> & {
+    content: EntryContentWriteResult;
+    blockState: Extract<DocumentBlockState, {
+        kind: 'entry-slots';
+    }>;
+}) | {
     entry: PageRecord;
-    publishedBlocks?: PublishedBlockBaseline[];
+    blockState: Extract<DocumentBlockState, {
+        kind: 'page';
+    }>;
 };
 export type PublishedContentEntryPreview = {
     id: string;
@@ -532,6 +567,7 @@ export type ListPublishedEntriesResponse<TContent = Record<string, unknown>> = {
  */
 type SdkRuntimeBlockContent<TScope, TContentVersionId extends string | null> = TScope & BlockContentIdentity & {
     id: string;
+    optimisticHash?: string;
     blockId: string;
     contentVersionId: TContentVersionId;
     kind: string;
@@ -627,29 +663,7 @@ export type SdkRuntimePageResponse = {
     templates?: SdkTemplate[];
     mediaAssets?: SdkRuntimeMediaAsset[];
 };
-export type SdkRuntimeEntry = {
-    id: string;
-    routeId: string | null;
-    type: string | null;
-    title: string;
-    slug: string | null;
-    status: string;
-    publishAt: string | null;
-    path: string | null;
-    draftPath: string | null;
-    content: Record<string, unknown>;
-    draftContent: Record<string, unknown> | null;
-    publishedContent: Record<string, unknown> | null;
-    metaTitle: string | null;
-    draftMetaTitle: string | null;
-    metaDescription: string | null;
-    draftMetaDescription: string | null;
-    ogImageId: string | null;
-    ogImageUrl: string | null;
-    canonicalUrl: string | null;
-    createdAt: string;
-    updatedAt: string;
-};
+export type { SdkRuntimeEntry, SdkEditorRevision } from './siteRuntimeEntry';
 export type SdkRuntimeEntryResponse = {
     entry: SdkRuntimeEntry;
     templates: SdkTemplate[];
@@ -666,6 +680,7 @@ export type SdkRuntimePageSurfaceContentSource = Readonly<{
 }>;
 export type SdkRuntimePageSurface = {
     id: string;
+    editorRevision?: SdkEditorRevision;
     routeId: string;
     readinessState: 'internal_pilot' | 'shippable';
     subject: SdkRuntimePageSurfaceSubject;
@@ -765,4 +780,3 @@ export type ContentDataResponse = {
         }>;
     }>;
 };
-export {};

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

@@ -176,13 +176,13 @@ export type DeleteContentTypeResponse = {
 export type DuplicateContentTypeResponse = {
     contentType: ContentTypeRecord;
 };
-export declare function listContentTypes(apiClient: ApiClient, { siteId, options, }: {
+export declare function listContentTypes(apiClient: ApiClient<'listContentTypes'>, { siteId, options, }: {
     siteId: string;
     options?: RequestInit;
 }): Promise<{
     contentTypes: SerializedContentTypeSummary[];
 }>;
-export declare function enableContentType(apiClient: ApiClient, { siteId, key, options, }: {
+export declare function enableContentType(apiClient: ApiClient<'enableContentType'>, { siteId, key, options, }: {
     siteId: string;
     key: 'post' | 'event' | 'testimonial' | (string & {});
     options?: RequestInit;
@@ -190,7 +190,7 @@ export declare function enableContentType(apiClient: ApiClient, { siteId, key, o
     ok: boolean;
     contentType: SerializedContentTypeSummary;
 }>;
-export declare function setupContentType(apiClient: ApiClient, { siteId, key, addListingPage, addNavItem, seedExample, listBlockKind, options, }: {
+export declare function setupContentType(apiClient: ApiClient<'setupContentType'>, { siteId, key, addListingPage, addNavItem, seedExample, listBlockKind, options, }: {
     siteId: string;
     key: 'post' | 'event' | 'testimonial' | (string & {});
     addListingPage?: boolean;
@@ -205,35 +205,35 @@ export declare function setupContentType(apiClient: ApiClient, { siteId, key, ad
     navItemId?: string;
     entryId?: string;
 }>;
-export declare function getContentTemplate(apiClient: ApiClient, { siteId, type, options, }: {
+export declare function getContentTemplate(apiClient: ApiClient<'getContentTemplate'>, { siteId, type, options, }: {
     siteId: string;
     type: string;
     options?: RequestInit;
 }): Promise<ContentTemplateDetailsResponse>;
-export declare function updateContentTemplateBlock(apiClient: ApiClient, { siteId, type, blockId, content, options, }: {
+export declare function updateContentTemplateBlock(apiClient: ApiClient<'updateContentTemplateBlock'>, { siteId, type, blockId, content, options, }: {
     siteId: string;
     type: string;
     blockId: string;
     content: Record<string, unknown>;
     options?: RequestInit;
 }): Promise<ContentTemplateDetailsResponse>;
-export declare function applyContentTemplateAddon(apiClient: ApiClient, { siteId, type, addonKey, options, }: {
+export declare function applyContentTemplateAddon(apiClient: ApiClient<'applyContentTemplateAddon'>, { siteId, type, addonKey, options, }: {
     siteId: string;
     type: string;
     addonKey: string;
     options?: RequestInit;
 }): Promise<ContentTemplateDetailsResponse>;
-export declare function updateContentTemplateBlockBindings(apiClient: ApiClient, { siteId, type, blockId, bindings, options, }: {
+export declare function updateContentTemplateBlockBindings(apiClient: ApiClient<'updateContentTemplateBlockBindings'>, { siteId, type, blockId, bindings, options, }: {
     siteId: string;
     type: string;
     blockId: string;
     bindings: Record<string, unknown>;
     options?: RequestInit;
 }): Promise<ContentTemplateDetailsResponse>;
-export declare function getTransforms(apiClient: ApiClient, { options, }?: {
+export declare function getTransforms(apiClient: ApiClient<'getTransforms'>, { options, }?: {
     options?: RequestInit;
 }): Promise<GetTransformsResponse>;
-export declare function createTemplateBlock(apiClient: ApiClient, { siteId, type, blockKind, scope, position, options, }: {
+export declare function createTemplateBlock(apiClient: ApiClient<'createTemplateBlock'>, { siteId, type, blockKind, scope, position, options, }: {
     siteId: string;
     type: string;
     blockKind: string;
@@ -241,13 +241,13 @@ export declare function createTemplateBlock(apiClient: ApiClient, { siteId, type
     position?: number;
     options?: RequestInit;
 }): Promise<ContentTemplateDetailsResponse>;
-export declare function deleteTemplateBlock(apiClient: ApiClient, { siteId, type, blockId, options, }: {
+export declare function deleteTemplateBlock(apiClient: ApiClient<'deleteTemplateBlock'>, { siteId, type, blockId, options, }: {
     siteId: string;
     type: string;
     blockId: string;
     options?: RequestInit;
 }): Promise<ContentTemplateDetailsResponse>;
-export declare function reorderTemplateBlocks(apiClient: ApiClient, { siteId, type, blockIds, options, }: {
+export declare function reorderTemplateBlocks(apiClient: ApiClient<'reorderTemplateBlocks'>, { siteId, type, blockIds, options, }: {
     siteId: string;
     type: string;
     blockIds: string[];

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

@@ -1,6 +1,6 @@
 import type { GetVersionHistoryResponse, ListVersionHistoryResponse, RestoreVersionHistoryRequest, RestoreVersionHistoryResponse } from "./contentVersionHistory";
 import type { ApiClient } from "./request";
-export declare function listContentEntryVersions(apiClient: ApiClient, input: {
+export declare function listContentEntryVersions(apiClient: ApiClient<"listContentEntryVersions">, input: {
     siteId: string;
     type: string;
     entryId: string;
@@ -8,14 +8,14 @@ export declare function listContentEntryVersions(apiClient: ApiClient, input: {
     cursor?: string;
     options?: RequestInit;
 }): Promise<ListVersionHistoryResponse>;
-export declare function getContentEntryVersion(apiClient: ApiClient, input: {
+export declare function getContentEntryVersion(apiClient: ApiClient<"getContentEntryVersion">, input: {
     siteId: string;
     type: string;
     entryId: string;
     versionId: string;
     options?: RequestInit;
 }): Promise<GetVersionHistoryResponse>;
-export declare function restoreContentEntryVersion(apiClient: ApiClient, input: {
+export declare function restoreContentEntryVersion(apiClient: ApiClient<"restoreContentEntryVersion">, input: {
     siteId: string;
     type: string;
     entryId: string;
@@ -23,20 +23,20 @@ export declare function restoreContentEntryVersion(apiClient: ApiClient, input:
     body: RestoreVersionHistoryRequest;
     options?: RequestInit;
 }): Promise<RestoreVersionHistoryResponse>;
-export declare function listPageVersions(apiClient: ApiClient, input: {
+export declare function listPageVersions(apiClient: ApiClient<"listPageVersions">, input: {
     siteId: string;
     pageId: string;
     limit?: number;
     cursor?: string;
     options?: RequestInit;
 }): Promise<ListVersionHistoryResponse>;
-export declare function getPageVersion(apiClient: ApiClient, input: {
+export declare function getPageVersion(apiClient: ApiClient<"getPageVersion">, input: {
     siteId: string;
     pageId: string;
     versionId: string;
     options?: RequestInit;
 }): Promise<GetVersionHistoryResponse>;
-export declare function restorePageVersion(apiClient: ApiClient, input: {
+export declare function restorePageVersion(apiClient: ApiClient<"restorePageVersion">, input: {
     siteId: string;
     pageId: string;
     versionId: string;

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

@@ -4,7 +4,7 @@ export declare const CANONICAL_REFUND_CONFLICT_CODES: readonly ["already_refunde
 export type CanonicalRefundConflictCode = (typeof CANONICAL_REFUND_CONFLICT_CODES)[number];
 export declare const CANONICAL_REFUND_PLANNER_ERROR_CODES: readonly ["already_refunded", "idempotency_amount_mismatch", "idempotency_method_mismatch", "idempotency_receipt_mismatch", "idempotency_scope_mismatch", "refund_in_progress", "invalid_amount", "amount_exceeds_remaining", "pass_revoke_requires_full_refund", "refund_failed"];
 export type CanonicalRefundPlannerErrorCode = (typeof CANONICAL_REFUND_PLANNER_ERROR_CODES)[number];
-export declare const CANONICAL_ADMIN_REFUND_FAILURE_CODES: readonly ["already_refunded", "idempotency_amount_mismatch", "idempotency_method_mismatch", "idempotency_receipt_mismatch", "idempotency_scope_mismatch", "refund_in_progress", "invalid_amount", "amount_exceeds_remaining", "pass_revoke_requires_full_refund", "refund_failed", "payment_intent_not_found", "stripe_error", "stale_pending_missing_context", "non_refundable_deposit_remaining", "deposit_refund_override_required", "refund_revoke_requires_full_line_refund", "payment_receipt_not_found", "payment_receipt_not_refundable", "payment_receipt_attribution_required"];
+export declare const CANONICAL_ADMIN_REFUND_FAILURE_CODES: readonly ["refund_blocked_by_live_payment_terms", "already_refunded", "idempotency_amount_mismatch", "idempotency_method_mismatch", "idempotency_receipt_mismatch", "idempotency_scope_mismatch", "refund_in_progress", "invalid_amount", "amount_exceeds_remaining", "pass_revoke_requires_full_refund", "refund_failed", "payment_intent_not_found", "stripe_error", "stale_pending_missing_context", "non_refundable_deposit_remaining", "deposit_refund_override_required", "refund_revoke_requires_full_line_refund", "payment_receipt_not_found", "payment_receipt_not_refundable", "payment_receipt_attribution_required"];
 export type CanonicalAdminRefundFailureCode = (typeof CANONICAL_ADMIN_REFUND_FAILURE_CODES)[number];
 export type CustomerMembershipPaymentRefundConflictCode = CanonicalRefundConflictCode;
 export declare const CUSTOMER_MEMBERSHIP_PAYMENT_REFUND_INVALID_CODES: readonly ["stripe_not_connected", "credit_refunds_disabled", "not_refundable", "invalid_amount", "amount_exceeds_remaining", "payment_receipt_not_found", "payment_receipt_not_refundable", "payment_receipt_attribution_required"];

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

@@ -0,0 +1,67 @@
+import type { RevisionedBlockListItem, PageSurfaceEditorDocument, ContentRouteRecord } from './contentRuntime';
+/** A settled block's complete values and next-write identity. */
+export type DocumentBlockBaseline = RevisionedBlockListItem & Readonly<{
+    orderIndex: number;
+    content: Record<string, unknown> | null;
+    draftContent: null;
+    publishedContent: Record<string, unknown> | null;
+    draftContentId: null;
+    publishedContentId: string | null;
+}>;
+/** Complete ordered block membership covered by a document lifecycle write. */
+export type DocumentBlockState = Readonly<{
+    kind: 'page';
+    pageId: string;
+    blocks: readonly DocumentBlockBaseline[];
+}> | Readonly<{
+    kind: 'entry-slots';
+    slots: readonly Readonly<{
+        entrySlotId: string;
+        slotKey: string;
+        blocks: readonly DocumentBlockBaseline[];
+    }>[];
+}> | Readonly<{
+    kind: 'surface-slots';
+    pageSurfaceId: string;
+    slots: readonly Readonly<{
+        surfaceSlotId: string;
+        slotKey: string;
+        compositionHash: string;
+        blocks: readonly DocumentBlockBaseline[];
+    }>[];
+}>;
+export type DiscardPageSurfaceResponse = Readonly<{
+    kind: 'unchanged';
+}> | Readonly<{
+    kind: 'discarded';
+    document: PageSurfaceEditorDocument;
+    blockState: Extract<DocumentBlockState, {
+        kind: 'surface-slots';
+    }>;
+}>;
+/**
+ * A publish moves the route's draft revision. `draftUpdatedAt` and `route` are what
+ * the publish itself wrote, from the same transaction, so an open editor adopts
+ * values and revision together. `noChange` still acknowledges the revisions observed
+ * under the publication lock without replacing document values.
+ */
+export type PublishPageSurfaceResponse = Readonly<{
+    revisions: Readonly<{
+        content: string;
+        metadata: string;
+    }>;
+}> & ({
+    publication: 'published';
+    draftUpdatedAt: string;
+    route: ContentRouteRecord;
+    document: PageSurfaceEditorDocument;
+    blockState: Extract<DocumentBlockState, {
+        kind: 'surface-slots';
+    }>;
+} | {
+    publication: 'noChange';
+    document: PageSurfaceEditorDocument;
+    blockState: Extract<DocumentBlockState, {
+        kind: 'surface-slots';
+    }>;
+});

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

@@ -4,33 +4,33 @@ import type { ApiClient } from './request';
 type RemoveDomainResponse = NonNullable<APIEndpoints['removeDomain']['response']>;
 type GetDomainDnsResponse = NonNullable<APIEndpoints['getDomainDns']['response']>;
 type VerifyDomainDnsResponse = NonNullable<APIEndpoints['verifyDomainDns']['response']>;
-export declare function listAccountDomains(apiClient: ApiClient, options?: RequestInit): Promise<SiteDomainRecord[]>;
-export declare function searchDomainsRequest(apiClient: ApiClient, query: string, options?: RequestInit): Promise<DomainSearchResultResponse>;
-export declare function registerDomainRequest(apiClient: ApiClient, input: RegisterDomainRequestPayload, options?: RequestInit): Promise<RegisterDomainResponse>;
-export declare function assignDomainToSiteRequest(apiClient: ApiClient, { domainId, siteId, options, }: {
+export declare function listAccountDomains(apiClient: ApiClient<'listAccountDomains'>, options?: RequestInit): Promise<SiteDomainRecord[]>;
+export declare function searchDomainsRequest(apiClient: ApiClient<'searchDomains'>, query: string, options?: RequestInit): Promise<DomainSearchResultResponse>;
+export declare function registerDomainRequest(apiClient: ApiClient<'registerDomain'>, input: RegisterDomainRequestPayload, options?: RequestInit): Promise<RegisterDomainResponse>;
+export declare function assignDomainToSiteRequest(apiClient: ApiClient<'assignDomain'>, { domainId, siteId, options, }: {
     domainId: string;
     siteId: string;
     options?: RequestInit;
 }): Promise<SiteDomainRecord>;
-export declare function removeDomainRequest(apiClient: ApiClient, { domainId, options }: {
+export declare function removeDomainRequest(apiClient: ApiClient<'removeDomain'>, { domainId, options }: {
     domainId: string;
     options?: RequestInit;
 }): Promise<RemoveDomainResponse>;
-export declare function syncCustomDomainToEdgeConfig(apiClient: ApiClient, siteId: string, options?: RequestInit): Promise<{
+export declare function syncCustomDomainToEdgeConfig(apiClient: ApiClient<'syncCustomDomainToEdgeConfig'>, siteId: string, options?: RequestInit): Promise<{
     success: boolean;
     domain: string;
     siteId: string;
     message: string;
 }>;
-export declare function retryDomainConfigRequest(apiClient: ApiClient, { domainId, options }: {
+export declare function retryDomainConfigRequest(apiClient: ApiClient<'retryDomainConfig'>, { domainId, options }: {
     domainId: string;
     options?: RequestInit;
 }): Promise<DomainConfigResult>;
-export declare function getDomainDnsRequest(apiClient: ApiClient, { domainId, options }: {
+export declare function getDomainDnsRequest(apiClient: ApiClient<'getDomainDns'>, { domainId, options }: {
     domainId: string;
     options?: RequestInit;
 }): Promise<GetDomainDnsResponse>;
-export declare function verifyDomainDnsRequest(apiClient: ApiClient, { domainId, options }: {
+export declare function verifyDomainDnsRequest(apiClient: ApiClient<'verifyDomainDns'>, { domainId, options }: {
     domainId: string;
     options?: RequestInit;
 }): Promise<VerifyDomainDnsResponse>;
@@ -41,13 +41,13 @@ type DomainIdRequest = {
     domainId: string;
     options?: RequestInit;
 };
-export declare function retryNameserversRequest(apiClient: ApiClient, { domainId, options }: DomainIdRequest): Promise<RetryNameserversResponse>;
-export declare function updateRegisteredDomainContactRequest(apiClient: ApiClient, { domainId, contact, options }: DomainIdRequest & {
+export declare function retryNameserversRequest(apiClient: ApiClient<'retryDomainNameservers'>, { domainId, options }: DomainIdRequest): Promise<RetryNameserversResponse>;
+export declare function updateRegisteredDomainContactRequest(apiClient: ApiClient<'updateRegisteredDomainContact'>, { domainId, contact, options }: DomainIdRequest & {
     contact: SiteDomainContactPayload;
 }): Promise<RegistrarLifecycleResponse>;
-export declare function setRegisteredDomainPrivacyRequest(apiClient: ApiClient, { domainId, enabled, options }: DomainIdRequest & RegistrarBooleanMutationRequest): Promise<RegistrarLifecycleResponse>;
-export declare function setRegisteredDomainAutoRenewRequest(apiClient: ApiClient, { domainId, enabled, options }: DomainIdRequest & RegistrarBooleanMutationRequest): Promise<RegistrarLifecycleResponse>;
-export declare function getRegisteredDomainRenewalPostureRequest(apiClient: ApiClient, { domainId, options }: DomainIdRequest): Promise<RegistrarRenewalPostureResponse>;
-export declare function retryVercelRequest(apiClient: ApiClient, { domainId, options }: DomainIdRequest): Promise<RetryVercelResponse>;
-export declare function retryResendRequest(apiClient: ApiClient, { domainId, options }: DomainIdRequest): Promise<RetryResendResponse>;
+export declare function setRegisteredDomainPrivacyRequest(apiClient: ApiClient<'setRegisteredDomainPrivacy'>, { domainId, enabled, options }: DomainIdRequest & RegistrarBooleanMutationRequest): Promise<RegistrarLifecycleResponse>;
+export declare function setRegisteredDomainAutoRenewRequest(apiClient: ApiClient<'setRegisteredDomainAutoRenew'>, { domainId, enabled, options }: DomainIdRequest & RegistrarBooleanMutationRequest): Promise<RegistrarLifecycleResponse>;
+export declare function getRegisteredDomainRenewalPostureRequest(apiClient: ApiClient<'getRegisteredDomainRenewalPosture'>, { domainId, options }: DomainIdRequest): Promise<RegistrarRenewalPostureResponse>;
+export declare function retryVercelRequest(apiClient: ApiClient<'retryDomainVercel'>, { domainId, options }: DomainIdRequest): Promise<RetryVercelResponse>;
+export declare function retryResendRequest(apiClient: ApiClient<'retryDomainResend'>, { domainId, options }: DomainIdRequest): Promise<RetryResendResponse>;
 export {};