@riverbankcms/sdk 0.147.0 → 0.148.0

package/dist/_dts/blocks/src/system/runtime/nodes/shared/MagicLinkForm.d.ts

@@ -1,25 +1,12 @@
 import React from 'react';
 export type MagicLinkFormProps = {
-    /** Initial email to pre-populate the form */
     initialEmail?: string;
-    /** Title shown above the form */
     title?: string;
-    /** Subtitle/description shown below the title */
     subtitle?: string;
-    /** Text for the submit button */
     buttonText?: string;
-    /** Success message shown after email is sent */
     successMessage?: string;
-    /** Called when successfully sent (optional) */
     onSuccess?: () => void;
-    /** CSS class prefix for styling (e.g., 'cp' for customer portal, 'er' for event registration, 'cr' for course registration) */
     classPrefix?: 'cp' | 'er' | 'cr' | 'er-whole-series';
-    /** Whether to show compact/inline styling */
     compact?: boolean;
 };
-/**
- * Reusable magic link login form.
- * Used by Customer Portal and Event Registration blocks.
- */
-export declare function MagicLinkForm({ initialEmail, title, subtitle, buttonText, successMessage, onSuccess, classPrefix, compact, }: MagicLinkFormProps): React.JSX.Element;
-export default MagicLinkForm;
+export declare function MagicLinkForm(props: MagicLinkFormProps): React.JSX.Element;

package/dist/_dts/blocks/src/system/runtime/nodes/shared/MagicLinkForm.state.d.ts

@@ -4,6 +4,12 @@ export type MagicLinkSubmissionState = Readonly<{
     tag: 'submitting';
 }> | Readonly<{
     tag: 'success';
+}> | Readonly<{
+    tag: 'demo_link';
+    url: string;
+}> | Readonly<{
+    tag: 'demo_refused';
+    message: string;
 }> | Readonly<{
     tag: 'error';
     message: string;
@@ -12,6 +18,12 @@ export type MagicLinkSubmissionAction = Readonly<{
     type: 'submit-started';
 }> | Readonly<{
     type: 'submit-succeeded';
+}> | Readonly<{
+    type: 'submit-demo-link';
+    url: string;
+}> | Readonly<{
+    type: 'submit-demo-refused';
+    message: string;
 }> | Readonly<{
     type: 'submit-failed';
     message: string;

package/dist/_dts/blocks/src/system/runtime/nodes/shop.interactive.d.ts

@@ -8,6 +8,7 @@ import { type InteractiveIslandProps } from '../../../contracts/islands';
 import type { BrowserReadAuthority } from '../api/types';
 type ShopSourceProps = ShopDisplayConfig & Readonly<{
     siteId?: string;
+    demoEmailSuppressed?: boolean;
     apiBaseUrl?: string;
     readAuthority?: BrowserReadAuthority;
     stage?: 'preview' | 'published';
@@ -17,6 +18,7 @@ export type PassesMembershipsHydration = Readonly<{
     memberships: readonly PublicMembershipProduct[];
     passPurchaseMode: 'add_to_cart' | 'buy_now';
     buttonVariant: BlockButtonRole;
+    demoEmailSuppressed?: boolean;
 }>;
 export type ProductListHydration = Readonly<{
     products: readonly PublicProduct[];
@@ -39,6 +41,7 @@ export type CartHydration = Readonly<{
 export type CheckoutHydration = Readonly<{
     emptyStateText: string;
     submitButtonText: string;
+    demoEmailSuppressed?: boolean;
 }>;
 type ShopIslandMeta = Readonly<{
     siteId?: string;
@@ -116,6 +119,7 @@ export declare const shopBlockRuntime: Readonly<{
             memberships: readonly PublicMembershipProduct[];
             passPurchaseMode: "add_to_cart" | "buy_now";
             buttonVariant: BlockButtonRole;
+            demoEmailSuppressed?: boolean;
         }>;
     }>;
     contracts: Readonly<{
@@ -164,6 +168,7 @@ export declare const shopBlockRuntime: Readonly<{
                     memberships: readonly PublicMembershipProduct[];
                     passPurchaseMode: "add_to_cart" | "buy_now";
                     buttonVariant: BlockButtonRole;
+                    demoEmailSuppressed?: boolean;
                 }>;
             }>) => unknown;
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
@@ -206,6 +211,7 @@ export declare const shopBlockRuntime: Readonly<{
                     memberships: readonly PublicMembershipProduct[];
                     passPurchaseMode: "add_to_cart" | "buy_now";
                     buttonVariant: BlockButtonRole;
+                    demoEmailSuppressed?: boolean;
                 }>;
             }>>;
         }>;
@@ -474,6 +480,7 @@ export declare const checkoutBlockRuntime: Readonly<{
         hydration: Readonly<{
             emptyStateText: string;
             submitButtonText: string;
+            demoEmailSuppressed?: boolean;
         }>;
     }>;
     contracts: Readonly<{
@@ -494,6 +501,7 @@ export declare const checkoutBlockRuntime: Readonly<{
                 hydration: Readonly<{
                     emptyStateText: string;
                     submitButtonText: string;
+                    demoEmailSuppressed?: boolean;
                 }>;
             }>) => unknown;
             decode: (input: unknown) => import("../../../contracts").DecodeResult<Readonly<{
@@ -508,6 +516,7 @@ export declare const checkoutBlockRuntime: Readonly<{
                 hydration: Readonly<{
                     emptyStateText: string;
                     submitButtonText: string;
+                    demoEmailSuppressed?: boolean;
                 }>;
             }>>;
         }>;
@@ -563,6 +572,7 @@ export declare const shopInteractiveIslandPropsCodec: Readonly<{
                 memberships: readonly PublicMembershipProduct[];
                 passPurchaseMode: "add_to_cart" | "buy_now";
                 buttonVariant: BlockButtonRole;
+                demoEmailSuppressed?: boolean;
             }>;
         }>>;
     }>) => unknown;
@@ -615,6 +625,7 @@ export declare const shopInteractiveIslandPropsCodec: Readonly<{
                 memberships: readonly PublicMembershipProduct[];
                 passPurchaseMode: "add_to_cart" | "buy_now";
                 buttonVariant: BlockButtonRole;
+                demoEmailSuppressed?: boolean;
             }>;
         }>>;
     }>>;
@@ -851,6 +862,7 @@ export declare const checkoutInteractiveIslandPropsCodec: Readonly<{
             hydration: Readonly<{
                 emptyStateText: string;
                 submitButtonText: string;
+                demoEmailSuppressed?: boolean;
             }>;
         }>>;
     }>) => unknown;
@@ -875,6 +887,7 @@ export declare const checkoutInteractiveIslandPropsCodec: Readonly<{
             hydration: Readonly<{
                 emptyStateText: string;
                 submitButtonText: string;
+                demoEmailSuppressed?: boolean;
             }>;
         }>>;
     }>>;

package/dist/_dts/blocks/src/system/runtime/shared/components/DemoBookingPortalAccess.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { BookingSuccessCopy } from '../../nodes/booking-form.state';
+export declare function BookingConfirmation(props: Readonly<{
+    demoEmailSuppressed?: boolean;
+    email: string | null;
+    copy: BookingSuccessCopy;
+    messagePresentation: BookingConfirmationMessagePresentation;
+    noteClassName?: string;
+    showConfirmationNote?: boolean;
+}>): React.ReactNode;
+export declare function DemoBookingPortalAccess(props: Readonly<{
+    email: string | null;
+    noteClassName?: string;
+    showConfirmationNote?: boolean;
+}>): React.ReactElement;
+type BookingConfirmationMessagePresentation = Readonly<{
+    kind: 'paragraph';
+    className?: string;
+}> | Readonly<{
+    kind: 'plain';
+}>;
+export {};

package/dist/_dts/blocks/src/system/runtime/shared/components/DemoPortalSignInLink.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare function DemoPortalSignInLink(props: Readonly<{
+    url: string;
+}>): React.ReactElement;

package/dist/_dts/blocks/src/system/runtime/shared/components/index.d.ts

@@ -12,6 +12,7 @@ export type { ActionRowProps } from './ActionRow';
 export { FieldValidationMessage, getFieldValidationControlProps, } from './FieldValidationMessage';
 export type { FieldValidationControlInput, FieldValidationControlProps, FieldValidationMessageProps, } from './FieldValidationMessage';
 export { FeedbackMessage } from './FeedbackMessage';
+export { DemoPortalSignInLink } from './DemoPortalSignInLink';
 export type { FeedbackLiveMode, FeedbackMessageProps, FeedbackTone, FeedbackTreatment, } from './FeedbackMessage';
 export { LoggedInAsUser } from './LoggedInAsUser';
 export { StateIcon } from './StateIcon';

package/dist/_dts/blocks/src/system/runtime/shared/utils/demoBookingPassStorage.d.ts

@@ -0,0 +1,10 @@
+export type StoredDemoBookingPass = Readonly<{
+    email: string;
+    pass: string;
+}>;
+export declare function normalizeDemoBookingEmail(email: string): string;
+export declare function storeDemoBookingPass(email: string, pass: string): void;
+export declare function storeDemoBookingPassIfAvailable(email: string | null | undefined, pass: string | null | undefined): void;
+export declare function getDemoBookingPass(email: string): string | null;
+export declare function storeDemoBookingCheckoutReturn(email: string, pass: string | null | undefined): void;
+export declare function readDemoBookingCheckoutReturnEmail(): string | null;

package/dist/_dts/blocks/src/system/runtime/shared/utils/demoPortalMagicLink.d.ts

@@ -0,0 +1,29 @@
+export declare const CUSTOMER_PORTAL_PATH = "/portal";
+export declare function buildPortalCallbackUrl(origin: string, redirectTo: string): string;
+export type DemoPortalMagicLinkRequest = Readonly<{
+    email: string;
+    redirectUrl: string;
+    demoBookingPass?: string;
+}>;
+export type DemoPortalMagicLinkResponse = Readonly<{
+    message: string;
+}> | Readonly<{
+    demoSignInUrl: string;
+}> | Readonly<{
+    kind: 'demo_email_not_booked_here';
+    message: string;
+}>;
+export type DemoPortalMagicLinkOutcome = Readonly<{
+    kind: 'email_sent';
+}> | Readonly<{
+    kind: 'demo_sign_in';
+    url: string;
+}> | Readonly<{
+    kind: 'refused';
+    message: string;
+}>;
+export declare function requestDemoPortalMagicLink(input: Readonly<{
+    email: string;
+    redirectUrl: string;
+    send: (request: DemoPortalMagicLinkRequest) => Promise<DemoPortalMagicLinkResponse>;
+}>): Promise<DemoPortalMagicLinkOutcome>;

package/dist/_dts/commerce/src/purchase/event-registration-errors.d.ts

@@ -48,6 +48,10 @@ export declare const eventRegistrationErrors: {
         readonly message: "The payment options for this event have changed. Please check the latest options before continuing.";
         readonly action: "payment-options";
     };
+    readonly verificationFailed: {
+        readonly message: "We couldn’t confirm this request came from a person. Please refresh the page and try again.";
+        readonly action: "none";
+    };
     readonly idempotencyConflict: {
         readonly message: "You’ve already started booking this event. Please finish in the other tab if it’s still open, or check your booking status before starting again.";
         readonly action: "portal";

package/dist/_dts/content-editor/src/components/ContentFieldsForm.d.ts

@@ -2,9 +2,8 @@ import { type ReactNode } from 'react';
 import type { BlockManifest } from '../../../blocks/src/index';
 import { type FieldWidgetComponent } from '../../../block-form/src/index';
 import type { ManifestFormSource } from '../../../block-form/src/index';
-export type { AutosaveHandle } from '../hooks/useSimpleAutosave';
+export type { AutosaveHandle } from '../ui/stores/types';
 export type ContentFieldsFormProps<TValues extends Record<string, unknown>> = {
-    siteId: string;
     manifest?: BlockManifest;
     form?: ManifestFormSource;
     /**
@@ -14,12 +13,8 @@ export type ContentFieldsFormProps<TValues extends Record<string, unknown>> = {
     initialValues?: TValues;
     paletteTokens?: Record<string, string>;
     widgets?: Partial<Record<string, FieldWidgetComponent>>;
-    mediaProvider?: (props: {
-        siteId: string;
-        children: ReactNode;
-    }) => ReactNode;
     errorComponent?: (props: {
         error: string;
     }) => ReactNode;
 };
-export declare function ContentFieldsForm<TValues extends Record<string, unknown>>({ siteId, manifest, form: formSpec, initialValues: _initialValues, paletteTokens, widgets, mediaProvider: MediaProvider, errorComponent: ErrorComponent, }: ContentFieldsFormProps<TValues>): import("react").JSX.Element;
+export declare function ContentFieldsForm<TValues extends Record<string, unknown>>({ manifest, form: formSpec, initialValues: _initialValues, paletteTokens, widgets, errorComponent: ErrorComponent, }: ContentFieldsFormProps<TValues>): import("react").JSX.Element;

package/dist/_dts/content-editor/src/controller/EditLeaseController.d.ts

@@ -0,0 +1,39 @@
+import { type ReactNode } from 'react';
+import type { ApiClient } from '../../../api/src/request';
+import type { DocumentLeaseReadInput } from './readDocumentLeaseBaselines';
+import type { EditLeaseScope } from '../../../core/src/index';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { EditLeaseLossSignal } from './editLeaseLossSignal';
+import { useEditLease, type EditLeaseChangeSubscription } from '../hooks/useEditLease';
+export type EditorLeaseConfig = Readonly<{
+    siteId: string;
+    scope: EditLeaseScope;
+    subscribeToLeaseChanges?: EditLeaseChangeSubscription;
+    /** Refresh display props after the authoritative baseline has been applied. */
+    onGranted?: () => void;
+    onAccessChanged?: () => void;
+}>;
+export type EditLeaseActions = ReturnType<typeof useEditLease>;
+/**
+ * Discarding is local and synchronous: it can't fail, and it happens before the tab leaves
+ * edit mode. Newer server values arrive by the take-back refresh on the next grant, or, in
+ * view mode, by live drafts and reload broadcasts.
+ */
+export type EditLeaseControllerActions = EditLeaseActions & Readonly<{
+    discardLocal: () => void;
+}>;
+/**
+ * Mounts the lease session only while `lease` is set. Children keep their position in the
+ * tree either way, so joining or leaving the lease never remounts the editor.
+ */
+export declare function EditLeaseController({ children, lease, ...session }: Readonly<{
+    children: ReactNode;
+    document: Pick<DocumentLeaseReadInput, 'type' | 'schema' | 'blockFieldExtensions'>;
+    lease: EditorLeaseConfig | null;
+    apiClient: ApiClient;
+    uiStore: EditorUiStoreInstance;
+    leaseLossSignal: EditLeaseLossSignal;
+    /** Rendered beside children, only while the lease session is mounted. */
+    sessionChildren?: ReactNode;
+}>): import("react").JSX.Element;
+export declare function useEditLeaseActions(): EditLeaseControllerActions | null;

package/dist/_dts/content-editor/src/controller/EditorWriteGate.d.ts

@@ -0,0 +1,38 @@
+import type { ReactNode } from 'react';
+import { type LeaseNotice, type LeaseNoticeAction } from './editLeaseNotice';
+export type LeaseNoticeHandlers = Readonly<Record<LeaseNoticeAction, () => void>>;
+/** Makes a mount's editing surface inert while the tab is waiting for, or denied, the lease. */
+export declare function EditorWriteSurface({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react").JSX.Element;
+export declare function LeaseNoticeButtons({ notice, handlers, size }: Readonly<{
+    notice: LeaseNotice;
+    handlers: LeaseNoticeHandlers;
+    size?: 'sm';
+}>): import("react").JSX.Element[];
+/** A blocking modal; it can't be dismissed, because the modal is the only way forward. */
+export declare function EditLeaseModalView({ notice, handlers }: Readonly<{
+    notice: LeaseNotice | null;
+    handlers: LeaseNoticeHandlers;
+}>): import("react").JSX.Element;
+/** The document's lease modal. Pass `onKeepViewing` where the tab can return to view mode. */
+export declare function EditLeaseModal({ thing, onKeepViewing }: Readonly<{
+    thing: string;
+    onKeepViewing?: () => void;
+}>): import("react").JSX.Element | null;
+export declare function LeaseDiscardedNoticeView({ thing, onDismiss }: Readonly<{
+    thing: string;
+    onDismiss: () => void;
+}>): import("react").JSX.Element;
+/** Shown after taking the lease back replaced edits another tab had changed. */
+export declare function EditLeaseDiscardedNotice({ thing }: Readonly<{
+    thing: string;
+}>): import("react").JSX.Element | null;
+/**
+ * One write gate per editor mount: the whole editing surface is inert while the tab can't
+ * write, and the lease modal explains why. The modal portals outside the inert subtree.
+ */
+export declare function EditorWriteGate({ thing, children }: Readonly<{
+    thing: string;
+    children: ReactNode;
+}>): import("react").JSX.Element;

package/dist/_dts/content-editor/src/controller/EntryControllerProvider.d.ts

@@ -1,13 +1,16 @@
 import { type ContentEntrySnapshot, type ContentTypeSchema, type ToolbarState } from '../../../content-model/src/index';
 import type { EditorBlockId, MailingListProviderScope } from '../../../core/src/index';
-import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
+import type { BlockItem, ServerBlockItem } from '../../../editor-blocks/src/block-editor/types';
 import { type ReactNode } from 'react';
-import { type PublishOptions } from '../hooks/useEntryActions';
-import type { BlockedPublishPlan } from '../hooks/blockedPublishPlan';
-import { type ApiClient, type ContentEditorServices } from '../services';
-import type { DraftWorkflowStatus } from '../types';
+import { type EntryActions } from '../hooks/useEntryActions';
+import { type BlockedPublishPlan } from '../hooks/blockedPublishPlan';
+import { type ContentEntryEditorServices, type PageSurfaceEditorServices } from '../services';
 import { type EditorUiState } from '../ui/editorUiStore';
 import type { ResolveBlockManifest } from '../ui/blockValidationView';
+import { type RouteWrites } from './routeWrites';
+import type { EditorApiClient, EditorApiClientFactory } from '../services/editorApiClient';
+import { type EditorLeaseParticipation } from './editorLeaseParticipation';
+import { type LiveDraftsConfig } from '../liveDrafts/useLiveDrafts';
 export type EntryControllerBlocksSlice = {
     list: BlockItem[];
     status: 'idle' | 'loading' | 'error';
@@ -16,10 +19,6 @@ export type EntryControllerBlocksSlice = {
     };
 };
 export type EntryControllerUiSlice = EditorUiState;
-export type EntryControllerAutosaveState = {
-    status: DraftWorkflowStatus;
-    hasFailedSaves: boolean;
-};
 export type EntryDraftBlockPatch = {
     blockId: EditorBlockId;
     path?: string | null;
@@ -47,18 +46,9 @@ export type EntryRecoveryConflictState = Readonly<{
     reviewAffectedBlocks: () => void;
     discardRecoveredChanges: () => void;
 }>;
-/** Actions returned by useEntryActions */
-export type EntryActions = Readonly<{
-    kind: 'entryLifecycle';
-    saveDraft: () => Promise<void>;
-    publish: (options?: PublishOptions) => Promise<void>;
-    discardDraft: () => Promise<void>;
-    deleteEntry: () => Promise<void>;
-}> | Readonly<{
-    kind: 'pageSurfaceDraft';
-    saveDraft: () => Promise<void>;
-}>;
+export type { EntryActions };
 export type EntryControllerContextValue = {
+    apiClient: EditorApiClient;
     entry: ContentEntrySnapshot;
     baseline: Record<string, unknown>;
     errorMessage: string | null;
@@ -66,21 +56,25 @@ export type EntryControllerContextValue = {
         type: 'blocked';
     }> | null;
     recoveryConflict: EntryRecoveryConflictState | null;
-    setErrorMessage: (msg: string | null) => void;
     actions: EntryActions;
+    /** Writes that return the route row they wrote (native publish, schedule, cancel). */
+    routeWrites: RouteWrites;
     blocks: EntryControllerBlocksSlice;
     drafts: EntryDraftsSlice;
     toolbar: ToolbarState<Record<string, unknown>>;
 };
 type BaseInternalProps = {
     children: ReactNode;
-    apiClient: ApiClient;
+    apiClientFactory: EditorApiClientFactory;
+    /** Viewing mounts no lease controller; switching to a lease config keeps the store and its edits. */
+    editLease: EditorLeaseParticipation;
     siteId: string;
     routeId?: string;
     type: string;
     schema: ContentTypeSchema;
     entityLabel?: string | null;
     initialEntry?: ContentEntrySnapshot | null;
+    initialMetadataRevision: string | null;
     /** Autosave mode (default: auto). Manual disables background autosave triggers. */
     saveMode?: 'auto' | 'manual';
     /** Initial content values for content entries - used to hydrate content store */
@@ -89,34 +83,35 @@ type BaseInternalProps = {
     initialPublishedContent?: Record<string, unknown> | null;
     onEntryUpdated?: (response: unknown) => void;
     historyShortcutsEnabled?: boolean;
+    blockFieldExtensions?: import('../../../editor-blocks/src/block-editor/blockDraftBaselineSeed').BlockFieldExtensions | null;
     resolveBlockManifest?: ResolveBlockManifest;
     getExpectedMailingListProviderScope?: () => MailingListProviderScope | null;
+    /** Live drafts between tabs (issue 1545); omitted where the host has no realtime client. */
+    liveDrafts?: LiveDraftsConfig | null;
 };
 type EditorOwnerServiceProps = Readonly<{
     owner: {
         kind: 'contentEntry';
         contentEntryId: string;
     };
-    services?: Extract<ContentEditorServices, {
-        kind: 'entryLifecycle';
-    }>;
+    services?: ContentEntryEditorServices;
 }> | Readonly<{
     owner: {
         kind: 'pageSurface';
         pageSurfaceId: string;
     };
-    services: Extract<ContentEditorServices, {
-        kind: 'pageSurfaceDraft';
-    }>;
+    services: PageSurfaceEditorServices | ((apiClient: EditorApiClient) => PageSurfaceEditorServices);
 }>;
 type PageInternalProps = {
     kind: 'page';
+    initialContentRevision?: never;
     initialStatus?: 'draft' | 'scheduled' | 'published';
-    initialBlocks?: BlockItem[];
+    initialBlocks?: ServerBlockItem[];
 };
 type ContentInternalProps = {
     kind: 'content';
-    initialBlocks?: BlockItem[];
+    initialContentRevision: string;
+    initialBlocks?: ServerBlockItem[];
 };
 type EntryControllerProviderProps = BaseInternalProps & EditorOwnerServiceProps & (PageInternalProps | ContentInternalProps);
 /**
@@ -137,34 +132,3 @@ type EntryControllerProviderProps = BaseInternalProps & EditorOwnerServiceProps
 export declare function EntryControllerProvider(props: EntryControllerProviderProps): import("react").JSX.Element;
 export declare function useEntryEditorController(): EntryControllerContextValue;
 export declare function useEntryController(): EntryControllerContextValue;
-/**
- * Hook to access autosave status from the uiStore.
- *
- * @deprecated Use useEditorUiStore with selectors instead for better performance:
- * ```tsx
- * const metadataStatus = useEditorUiStore(state => state.autosave.metadata.status)
- * const blocksStatus = useEditorUiStore(state => state.autosave.blocks.status)
- * ```
- *
- * This hook exists for backward compatibility and subscribes to the entire
- * autosave state, causing re-renders when any autosave status changes.
- */
-export declare function useAutosave(): {
-    autosave: import("../ui/editorUiStore").AutosaveStatus;
-    blockAutosave: import("../ui/editorUiStore").AutosaveStatus;
-};
-/**
- * @deprecated Use useEditorUiStore hook directly from '../ui/editorUiStore'
- * This provides granular selector support for better performance.
- *
- * Example:
- * ```tsx
- * // Old (re-renders on any state change):
- * const uiStore = useEntryUiStore()
- *
- * // New (only re-renders when metadata status changes):
- * const metadataStatus = useEditorUiStore(state => state.metadata.getSnapshot().syncState.kind)
- * ```
- */
-export declare function useEntryUiStore(): import("zustand").StoreApi<EditorUiState>;
-export {};

package/dist/_dts/content-editor/src/controller/LinkedEntryLeaseBanner.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A linked entry held elsewhere keeps a notice scoped to its panel: it doesn't make the whole
+ * page read-only, so it never raises the page's modal.
+ */
+export declare function LinkedEntryLeaseBanner({ entryId }: Readonly<{
+    entryId: string;
+}>): import("react").JSX.Element | null;

package/dist/_dts/content-editor/src/controller/LinkedEntryLeaseControllers.d.ts

@@ -0,0 +1,14 @@
+import type { EditorApiClient, EditorApiClientFactory } from '../services/editorApiClient';
+import { type EditorLeaseConfig } from './EditLeaseController';
+type Props = Readonly<{
+    apiClientFactory: EditorApiClientFactory;
+    parentApiClient: EditorApiClient;
+    lease: EditorLeaseConfig;
+}>;
+/**
+ * A linked entry keeps its lease controller, and so its lease authority, while it's
+ * selected, edited, or has a request in flight or abandoned; it unmounts only once that
+ * request settles (issue 1553, D2 and row L6).
+ */
+export declare function LinkedEntryLeaseControllers(props: Props): import("react").JSX.Element[];
+export {};

package/dist/_dts/content-editor/src/controller/deriveEditorUnpublishedState.d.ts

@@ -18,3 +18,9 @@ export type DeriveEditorUnpublishedStateInput = Readonly<{
     hasBeenPublishedBefore: boolean;
 }>;
 export declare function deriveEditorUnpublishedState(input: DeriveEditorUnpublishedStateInput): EditorUnpublishedState;
+/**
+ * Discard returns a document to its published version, so it needs both
+ * something to discard and a published version to go back to. A document that
+ * has never been published keeps its drafts, and its Discard is unavailable.
+ */
+export declare function canDiscardDraft(state: Pick<EditorUnpublishedState, "hasUnpublishedChanges" | "hasBeenPublishedBefore">): boolean;

package/dist/_dts/content-editor/src/controller/documentValueBaseline.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A document value (its metadata or its content) as the server last gave it:
+ * the draft the editor starts from, the published version it compares
+ * against, and the revision the next save is checked with.
+ *
+ * Kept free of imports so the editor services, which also run beside the
+ * server, can describe a discard result without pulling in the block editor.
+ */
+export type DocumentValueBaseline = Readonly<{
+    baseline: Record<string, unknown> | null;
+    published: Record<string, unknown> | null;
+    revision: string | null;
+}>;
+/** Unknown publication evidence retains the existing baseline; known null clears it. */
+export type SavedPublication = Readonly<{
+    kind: 'unknown';
+}> | Readonly<{
+    kind: 'known';
+    values: Record<string, unknown> | null;
+}>;
+export type DocumentSaveReceipt<TRevision extends string | null = string | null> = Readonly<{
+    values: Record<string, unknown>;
+    revision: TRevision;
+    published: SavedPublication;
+}>;

package/dist/_dts/content-editor/src/controller/editLeaseLossSignal.d.ts

@@ -0,0 +1,6 @@
+/** Connects save responses to the mounted lease controller without storing protocol state. */
+export declare function createEditLeaseLossSignal(): {
+    emit: () => void;
+    subscribe: (listener: () => void) => () => void;
+};
+export type EditLeaseLossSignal = ReturnType<typeof createEditLeaseLossSignal>;

package/dist/_dts/content-editor/src/controller/editLeaseNotice.d.ts

@@ -0,0 +1,28 @@
+import type { EditorEditability } from './editorEditability';
+/**
+ * What a lease notice button does; "Edit here" and "Take over" both take the lease.
+ * `keep-viewing` only returns the tab to view mode; `discard-and-view` throws away the
+ * tab's unsaved edits first, so the label always says what the click does.
+ */
+export type LeaseNoticeAction = 'take-over' | 'retry' | 'discard' | 'keep-viewing' | 'discard-and-view';
+export type LeaseNoticeButton = Readonly<{
+    action: LeaseNoticeAction;
+    label: string;
+}>;
+export type LeaseNotice = Readonly<{
+    variant: 'your-other-tab' | 'another-user' | 'lost-with-unsaved' | 'unreachable';
+    title: string;
+    body: string | null;
+    buttons: readonly LeaseNoticeButton[];
+}>;
+export type LeaseNoticeInput = Readonly<{
+    editability: EditorEditability;
+    /** "this page", "this entry" or "this event page". */
+    thing: string;
+    unsaved: boolean;
+    /** Preview only: the tab can go back to view mode instead. */
+    canKeepViewing: boolean;
+}>;
+/** The blocking notice for a read-only mount, or null when nothing should be said. */
+export declare function planLeaseNotice({ editability, thing, unsaved, canKeepViewing }: LeaseNoticeInput): LeaseNotice | null;
+export declare function leaseDiscardedMessage(thing: string): string;

package/dist/_dts/content-editor/src/controller/editorClientId.d.ts

@@ -0,0 +1,2 @@
+/** One id per document, including when a browser duplicates a tab. */
+export declare function getEditorClientId(): string;

package/dist/_dts/content-editor/src/controller/editorEditability.d.ts

@@ -0,0 +1,38 @@
+import type { EditAuthority, EditLeaseHolder, EditLeaseToken } from '../../../core/src/index';
+/**
+ * Why a store writes without a lease: a server-side exemption, or a surface the lease
+ * protocol does not manage (the footer composer and standalone stores).
+ */
+export type UnleasedReason = Extract<EditAuthority, {
+    kind: 'exempt';
+}>['reason'] | 'unmanaged-surface';
+/**
+ * A mount either declares an exemption, participates in the lease protocol, or is only
+ * viewing (a preview tab that has not asked to edit, so it never competes for the lease).
+ */
+export type EditorEditability = Readonly<{
+    kind: 'unleased';
+    reason: UnleasedReason;
+}> | Readonly<{
+    kind: 'viewing';
+}> | Readonly<{
+    kind: 'acquiring';
+}> | Readonly<{
+    kind: 'editable';
+    token: EditLeaseToken;
+}> | Readonly<{
+    kind: 'read-only';
+    reason: 'held-elsewhere';
+    holder: EditLeaseHolder;
+}> | Readonly<{
+    kind: 'read-only';
+    reason: 'unreachable';
+}>;
+/** The explicit editability of a store that no lease manages, such as the footer composer. */
+export declare const unmanagedSurfaceEditability: EditorEditability;
+export declare function canEditorWrite(editability: EditorEditability): boolean;
+/**
+ * Whether a mount's editing surface is made inert. A viewer is never blocked (its writes are
+ * refused by the store and the API client instead); a tab waiting for or denied the lease is.
+ */
+export declare function blocksEditingSurface(editability: EditorEditability): boolean;