@riverbankcms/sdk 0.80.0 → 0.82.0

package/dist/_dts/content-model/src/metadataConfig.d.ts

@@ -1,77 +1,113 @@
-type VisibilityRole = "admin" | "designer" | "author";
-type BlockManifestUi = {
-    showSlugPreview?: boolean;
-    showCharCount?: number | {
-        max: number;
-    };
-    visibleWhen?: {
-        field: string;
-        equals?: unknown;
-        notEquals?: unknown;
-        oneOf?: unknown[];
-        notIn?: unknown[];
-    };
+import type { ContentEntrySnapshot } from "./types";
+declare const nonEmptyPageRouteSlugBrand: unique symbol;
+export type NonEmptyPageRouteSlug = string & {
+    readonly [nonEmptyPageRouteSlugBrand]: "NonEmptyPageRouteSlug";
 };
-type BaseBlockManifestField = {
-    id: string;
+export type PageRouteSlug = Readonly<{
+    kind: "homepage";
+}> | Readonly<{
+    kind: "slug";
+    value: NonEmptyPageRouteSlug;
+}>;
+export type RouteMetadataManifestContext = Readonly<{
+    kind: "page";
+    routeSlug: PageRouteSlug;
+}> | Readonly<{
+    kind: "content";
+    typeKey?: string | null;
+}>;
+export type RouteMetadataPresentation = Readonly<{
+    kind: "page-homepage";
+    manifest: RouteMetadataManifest;
+    routeSlug: Extract<PageRouteSlug, {
+        kind: "homepage";
+    }>;
+}> | Readonly<{
+    kind: "page-routable";
+    manifest: RouteMetadataManifest;
+    routeSlug: Extract<PageRouteSlug, {
+        kind: "slug";
+    }>;
+}> | Readonly<{
+    kind: "content";
+    manifest: RouteMetadataManifest;
+    typeKey: string | null;
+}>;
+export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+type RouteMetadataTextField = {
+    id: "draftTitle" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+    type: "text";
     label: string;
     description?: string;
-    visibleRoles?: VisibilityRole[];
-    defaultValue?: unknown;
     required: boolean;
-    ui?: BlockManifestUi;
-};
-type TextBlockManifestField = BaseBlockManifestField & {
-    type: "text";
     multiline: boolean;
-    maxLength?: number;
+    ui?: {
+        showCharCount?: {
+            max: number;
+        };
+    };
 };
-type SlugBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataSlugField = {
+    id: "draftSlug";
     type: "slug";
-    sourceFieldId?: string;
-    statusFieldId?: string;
-    maxLength?: number;
+    label: string;
+    description: string;
+    required: true;
+    sourceFieldId?: "draftTitle";
+    statusFieldId: "draftStatus";
+    maxLength: number;
+    ui: {
+        showSlugPreview: true;
+    };
 };
-type SelectBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataSelectField = {
+    id: "draftStatus";
     type: "select";
+    label: string;
+    description: string;
+    required: true;
+    defaultValue: string;
     options: Array<{
         value: string;
         label: string;
-        description?: string;
-        icon?: string;
     }>;
-    multiple: boolean;
+    multiple: false;
 };
-type DateTimeBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataDatetimeField = {
+    id: "scheduledPublishAt";
     type: "datetime";
-};
-type BlockManifestField = TextBlockManifestField | SlugBlockManifestField | SelectBlockManifestField | DateTimeBlockManifestField;
-type BlockManifestSlot = {
-    id: string;
     label: string;
-    allowedKinds: string[];
-    min: number;
-    max?: number;
-    help?: string;
-    visibleRoles?: VisibilityRole[];
+    description: string;
+    required: false;
+    ui: {
+        visibleWhen: {
+            field: "draftStatus";
+            equals: "scheduled";
+        };
+    };
 };
-type BlockManifest = {
+export type RouteMetadataField = RouteMetadataTextField | RouteMetadataSlugField | RouteMetadataSelectField | RouteMetadataDatetimeField;
+export type RouteMetadataManifest = {
     name: string;
     version: string;
     title: string;
     description: string;
     component: string;
-    fields: BlockManifestField[];
-    slots: BlockManifestSlot[];
+    fields: RouteMetadataField[];
+    slots: [];
 };
-export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
-export declare const ROUTE_METADATA_MANIFEST: BlockManifest;
+export declare const ROUTE_METADATA_MANIFEST: RouteMetadataManifest;
 export declare const METADATA_WORKFLOW_FIELDS: {
     readonly title: "draftTitle";
     readonly slug: "draftSlug";
     readonly status: "draftStatus";
     readonly publishAt: "scheduledPublishAt";
 };
+export declare function pageRouteSlugFromEditorValue(value: string | null | undefined): PageRouteSlug;
+export declare function pageRouteSlugToEditorValue(slug: PageRouteSlug): string;
+export declare function pageRouteSlugToStoredValue(slug: PageRouteSlug): string | null;
+export declare function isHomepagePageRouteSlug(slug: PageRouteSlug): boolean;
+export declare function resolvePageRouteSlug(entry: ContentEntrySnapshot, currentSlug?: string | null): PageRouteSlug | null;
 export declare const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE: {
     readonly event: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
     readonly course: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
@@ -82,13 +118,17 @@ export declare const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE: {
 export declare function getManagedRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
 export declare function isRouteMetadataFieldEditableForType(typeKey: string | null | undefined, fieldId: string): boolean;
 export declare function getEditableRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
-export declare function getRouteMetadataManifestForType(typeKey: string | null | undefined): BlockManifest;
+export declare function getRouteMetadataManifestForType(typeKey: string | null | undefined): RouteMetadataManifest;
+export declare function getRouteMetadataManifestForContext(context: RouteMetadataManifestContext): RouteMetadataManifest;
+export declare function deriveRouteMetadataPresentation(context: RouteMetadataManifestContext, options?: Readonly<{
+    omitTitle?: boolean;
+}>): RouteMetadataPresentation;
 /**
  * Remove the legacy route title editor from a route metadata manifest.
  *
  * Entry titles are now derived from entry data (single source of truth) and the route title is a denormalized copy.
  * We still keep `draftTitle` in the underlying manifest for page creation flows, but we omit it from entry editors.
  */
-export declare function omitRouteTitleFieldFromManifest(manifest: BlockManifest): BlockManifest;
+export declare function omitRouteTitleFieldFromManifest(manifest: RouteMetadataManifest): RouteMetadataManifest;
 export declare function sanitizeSlug(value: string): string;
 export {};

package/dist/_dts/content-model/src/templates/defaults.d.ts

@@ -251,7 +251,6 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 readonly heading: "";
                 readonly showSummary: true;
                 readonly showBody: true;
-                readonly showBadges: true;
                 readonly addButtonText: "Add to cart";
                 readonly emptyStateText: "Product unavailable.";
             };

package/dist/_dts/core/src/branded.d.ts

@@ -75,6 +75,8 @@ export type BookingCalendarFeedTokenPublicId = Brand<string, 'BookingCalendarFee
 export type BookingCalendarFeedTokenSecret = Brand<string, 'BookingCalendarFeedTokenSecret'>;
 export type BookingCalendarFeedTokenSecretHash = Brand<string, 'BookingCalendarFeedTokenSecretHash'>;
 export type ContentEntryId = Brand<string, 'ContentEntryId'>;
+export type ContentVersionId = Brand<string, 'ContentVersionId'>;
+export type EntryContentHash = Brand<string, 'EntryContentHash'>;
 export type StripeInvoiceId = Brand<string, 'StripeInvoiceId'>;
 export type NewsletterSubscriberId = Brand<string, 'NewsletterSubscriberId'>;
 export type NavigationMenuId = Brand<string, 'NavigationMenuId'>;
@@ -186,6 +188,8 @@ export declare const unsafeAsBookingCalendarFeedTokenPublicId: (id: string) => B
 export declare const unsafeAsBookingCalendarFeedTokenSecret: (value: string) => BookingCalendarFeedTokenSecret;
 export declare const unsafeAsBookingCalendarFeedTokenSecretHash: (value: string) => BookingCalendarFeedTokenSecretHash;
 export declare const unsafeAsContentEntryId: (id: string) => ContentEntryId;
+export declare const unsafeAsContentVersionId: (id: string) => ContentVersionId;
+export declare const unsafeAsEntryContentHash: (value: string) => EntryContentHash;
 export declare const unsafeAsStripeInvoiceId: (id: string) => StripeInvoiceId;
 export declare const unsafeAsNewsletterSubscriberId: (id: string) => NewsletterSubscriberId;
 export declare const unsafeAsNavigationMenuId: (id: string) => NavigationMenuId;
@@ -229,6 +233,7 @@ export declare const parseProductVariantId: (value: unknown) => Result<ProductVa
 export declare const parseProductCategoryId: (value: unknown) => Result<ProductCategoryId, BrandedIdParseError>;
 export declare const parseMediaAssetId: (value: unknown) => Result<MediaAssetId, BrandedIdParseError>;
 export declare const parseContentEntryId: (value: unknown) => Result<ContentEntryId, BrandedIdParseError>;
+export declare const parseContentVersionId: (value: unknown) => Result<ContentVersionId, BrandedIdParseError>;
 export declare const parseNavigationMenuId: (value: unknown) => Result<NavigationMenuId, BrandedIdParseError>;
 export declare const parseNavigationItemId: (value: unknown) => Result<NavigationItemId, BrandedIdParseError>;
 export declare const parsePassId: (value: unknown) => Result<PassId, BrandedIdParseError>;

package/dist/_dts/core/src/event-pricing.d.ts

@@ -1,3 +1,75 @@
 export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types"];
 export type EventPricingMode = (typeof EVENT_PRICING_MODES)[number];
+export type PublicEventPricingType = "free" | "paid";
+export type PublicCoursePriceDisplay = Readonly<{
+    kind: "free";
+    currency: string;
+}> | Readonly<{
+    kind: "exact";
+    amount: number;
+    currency: string;
+}> | Readonly<{
+    kind: "from";
+    amount: number;
+    currency: string;
+}> | Readonly<{
+    kind: "unavailable";
+    currency: string;
+}>;
+export type PublicEventFreePriceDisplay = Readonly<{
+    kind: "free";
+    currency: string;
+}>;
+export type PublicEventExactPriceDisplay = Readonly<{
+    kind: "exact";
+    amount: number;
+    currency: string;
+}>;
+export type PublicEventTicketTypePriceDisplay = PublicEventFreePriceDisplay | PublicEventExactPriceDisplay | Readonly<{
+    kind: "from";
+    amount: number;
+    currency: string;
+}> | Readonly<{
+    kind: "mixed";
+    paidFromAmount: number;
+    currency: string;
+}> | Readonly<{
+    kind: "unavailable";
+    currency: string;
+}>;
+export type PublicEventPriceDisplay = PublicEventTicketTypePriceDisplay | Readonly<{
+    kind: "course";
+    display: PublicCoursePriceDisplay;
+}>;
+export type PublicEventPricing<TTicketType = never> = Readonly<{
+    kind: "drop_in";
+    currency: string;
+    display: PublicEventFreePriceDisplay;
+}> | Readonly<{
+    kind: "free_registration";
+    currency: string;
+    display: PublicEventFreePriceDisplay;
+}> | Readonly<{
+    kind: "single_paid";
+    amount: number;
+    currency: string;
+    display: PublicEventExactPriceDisplay;
+}> | Readonly<{
+    kind: "ticket_types";
+    currency: string;
+    ticketTypes: readonly TTicketType[];
+    display: PublicEventTicketTypePriceDisplay;
+}> | Readonly<{
+    kind: "course";
+    display: Readonly<{
+        kind: "course";
+        display: PublicCoursePriceDisplay;
+    }>;
+}>;
 export declare function isEventPricingMode(value: unknown): value is EventPricingMode;
+export declare function publicEventPricingDisplay(pricing: PublicEventPricing<unknown>): PublicEventPriceDisplay;
+export declare function publicEventPricingType(pricing: PublicEventPricing<unknown>): PublicEventPricingType;
+export declare function publicEventPricingCurrency(pricing: PublicEventPricing<unknown>): string | null;
+export declare function publicEventScalarPrice(pricing: PublicEventPricing<unknown>): number | null;
+export declare function publicEventPricingMode(pricing: PublicEventPricing<unknown>): EventPricingMode | undefined;
+export declare function publicEventTicketTypes<TTicketType>(pricing: PublicEventPricing<TTicketType>): readonly TTicketType[];

package/dist/_dts/core/src/index.d.ts

@@ -41,5 +41,6 @@ export * from "./email-format";
 export * from "./slug";
 export * from "./string";
 export * from "./uuid";
+export * from "./stable-json";
 export { disabledSelection, enabledSelection, plannerNoChange, plannerPatch, plannerUpdate, resolvePlanningDateInput, resolvePlanningNow, resolvePlanningNowDate, systemPlanningClock, } from "./planner";
 export type { DisabledSelection, EnabledSelection, OptionalSelection, PlannerNoChange, PlannerPatch, PlannerUpdate, PlanningClock, PlanningDateInput, PlanningTimeOptions, } from "./planner";

package/dist/_dts/core/src/stable-json.d.ts

@@ -0,0 +1 @@
+export declare function stableJsonStringify(value: unknown): string;

package/dist/_dts/db/src/generated/supabase/database.types.d.ts

@@ -15534,6 +15534,31 @@ export type Database = {
                     target_kind: string;
                 }[];
             };
+            commit_content_draft_version: {
+                Args: {
+                    p_data: Json;
+                    p_design_state: Json;
+                    p_expected_draft_updated_at: string;
+                    p_expected_draft_version_id: string;
+                    p_owner_id: string;
+                    p_owner_kind: Database["public"]["Enums"]["content_owner_kind"];
+                    p_site_id: string;
+                    p_user_id: string;
+                    p_version: number;
+                };
+                Returns: {
+                    block_id: string;
+                    content_entry_id: string;
+                    data: Json;
+                    design_state: Json;
+                    id: string;
+                    owner_kind: Database["public"]["Enums"]["content_owner_kind"];
+                    page_id: string;
+                    stage: Database["public"]["Enums"]["content_stage"];
+                    updated_at: string;
+                    version: number;
+                }[];
+            };
             complete_demo_lifecycle_job_lease: {
                 Args: {
                     p_error_message?: string;
@@ -17244,13 +17269,13 @@ export type Enums<DefaultSchemaEnumNameOrOptions extends keyof DefaultSchema["En
 } ? keyof DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"] : never = never> = DefaultSchemaEnumNameOrOptions extends {
     schema: keyof DatabaseWithoutInternals;
 } ? DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"][EnumName] : DefaultSchemaEnumNameOrOptions extends keyof DefaultSchema["Enums"] ? DefaultSchema["Enums"][DefaultSchemaEnumNameOrOptions] : never;
-export type CompositeTypes<PublicCompositeTypeNameOrOptions extends keyof DefaultSchema["CompositeTypes"] | {
+export type CompositeTypes<PublicCompositeTypeNameOrOptions extends {
     schema: keyof DatabaseWithoutInternals;
 }, CompositeTypeName extends PublicCompositeTypeNameOrOptions extends {
     schema: keyof DatabaseWithoutInternals;
 } ? keyof DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"] : never = never> = PublicCompositeTypeNameOrOptions extends {
     schema: keyof DatabaseWithoutInternals;
-} ? DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName] : PublicCompositeTypeNameOrOptions extends keyof DefaultSchema["CompositeTypes"] ? DefaultSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions] : never;
+} ? DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName] : never;
 export declare const Constants: {
     readonly graphql_public: {
         readonly Enums: {};

package/dist/_dts/db/src/schemas/forms.d.ts

@@ -120,9 +120,9 @@ export declare const bookingQuestionsFormSettingsSchema: z.ZodObject<{
         confirmationVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodNull]>;
     }, z.core.$strict>>;
     audienceHint: z.ZodOptional<z.ZodEnum<{
+        mixed: "mixed";
         courses: "courses";
         events: "events";
-        mixed: "mixed";
         appointments: "appointments";
     }>>;
     customerTitle: z.ZodOptional<z.ZodString>;
@@ -216,9 +216,9 @@ export declare const formSettingsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         confirmationVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodNull]>;
     }, z.core.$strict>>;
     audienceHint: z.ZodOptional<z.ZodEnum<{
+        mixed: "mixed";
         courses: "courses";
         events: "events";
-        mixed: "mixed";
         appointments: "appointments";
     }>>;
     customerTitle: z.ZodOptional<z.ZodString>;
@@ -319,9 +319,9 @@ export declare const formSettingsInputSchema: z.ZodDiscriminatedUnion<[z.ZodObje
         confirmationVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodNull]>;
     }, z.core.$strict>>;
     audienceHint: z.ZodOptional<z.ZodEnum<{
+        mixed: "mixed";
         courses: "courses";
         events: "events";
-        mixed: "mixed";
         appointments: "appointments";
     }>>;
     customerTitle: z.ZodOptional<z.ZodString>;
@@ -1015,9 +1015,9 @@ export declare const createFormPayloadSchema: z.ZodObject<{
             confirmationVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodNull]>;
         }, z.core.$strict>>;
         audienceHint: z.ZodOptional<z.ZodEnum<{
+            mixed: "mixed";
             courses: "courses";
             events: "events";
-            mixed: "mixed";
             appointments: "appointments";
         }>>;
         customerTitle: z.ZodOptional<z.ZodString>;

package/dist/_dts/editor/src/EditorProvider.d.ts

@@ -0,0 +1,26 @@
+import React, { type ReactNode } from 'react';
+export type DrawerFocusTarget = {
+    blockId: string | null;
+    fieldPath?: string | null;
+    itemIndex?: number | null;
+};
+export type DraftSyncState = 'baseline' | 'pending' | 'failed';
+interface EditorContextType {
+    isEditingMode: boolean;
+    toggleEditingMode: () => void;
+    setEditingMode: (value: boolean) => void;
+    editingElement: string | null;
+    setEditingElement: (elementId: string | null) => void;
+    currentBlockId?: string;
+    setCurrentBlock: (id: string | undefined) => void;
+    drawerFocus: DrawerFocusTarget | null;
+    setDrawerFocus: (target: DrawerFocusTarget | null) => void;
+    clearDrawerFocus: () => void;
+}
+export declare const useEditor: () => EditorContextType;
+interface EditorProviderProps {
+    children: ReactNode;
+    initialEditingMode?: boolean;
+}
+export declare const EditorProvider: React.FC<EditorProviderProps>;
+export {};

package/dist/_dts/editor/src/chrome/EditorChrome.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import { type EditorHistoryBarControls, type EditorStatusBarToolbar, type StatusBarMenuItem } from './EditorStatusBar';
+type EditorChromeProps = {
+    toolbarOverrides?: Partial<EditorStatusBarToolbar>;
+    onPublish?: () => void | Promise<void>;
+    onDiscard?: () => void | Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    messageOverride?: string | null;
+    messageVariant?: 'default' | 'manual-save';
+    actionButtonSize?: 'sm' | 'default' | 'lg';
+    showStatusBar?: boolean;
+    showToggle?: boolean;
+    /** Override kebab menu items; pass [] to hide menu entirely. */
+    menuItems?: StatusBarMenuItem[];
+    /** Add kebab menu items that only appear on mobile. */
+    mobileMenuItems?: StatusBarMenuItem[];
+    status?: 'idle' | 'saving' | 'success' | 'error';
+    lastSavedAt?: string | null;
+    draftSyncState?: 'baseline' | 'pending' | 'failed';
+    hasFailedSaves?: boolean;
+    onRetryFailedSaves?: () => void | Promise<void>;
+    historyControls?: EditorHistoryBarControls;
+};
+export declare function EditorChrome({ toolbarOverrides, onPublish, onDiscard, publishMenuItems, actionsSlot, messageOverride, messageVariant, actionButtonSize, showStatusBar, showToggle, menuItems: menuItemsOverride, mobileMenuItems, status, lastSavedAt, draftSyncState, hasFailedSaves, onRetryFailedSaves, historyControls, }: EditorChromeProps): import("react").JSX.Element;
+export {};

package/dist/_dts/editor/src/chrome/EditorStatusBar.d.ts

@@ -0,0 +1,45 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { DraftSyncState } from "../EditorProvider";
+export type DraftWorkflowStatus = "idle" | "saving" | "success" | "error";
+export type EditorStatusBarToolbar = {
+    publishLabel?: string;
+    hasUnpublishedChanges?: boolean;
+    disablePublish?: boolean;
+    disableDiscard?: boolean;
+    currentStatus?: string | null;
+    publishedMessage?: string | null;
+};
+export type EditorHistoryBarControls = {
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+};
+export type StatusBarMenuItem = {
+    label: string;
+    onClick: () => void;
+    variant?: "default" | "destructive";
+};
+export type EditorStatusBarProps = {
+    status: DraftWorkflowStatus;
+    lastSavedAt: string | null;
+    toolbar?: EditorStatusBarToolbar;
+    draftSyncState?: DraftSyncState;
+    onPublish?: () => void | Promise<void>;
+    onDiscard?: () => void | Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    toggleSlot?: ReactNode;
+    messageOverride?: string | null;
+    messageVariant?: "default" | "manual-save";
+    actionButtonSize?: "sm" | "default" | "lg";
+    hasFailedSaves?: boolean;
+    onRetryFailedSaves?: () => void | Promise<void>;
+    historyControls?: EditorHistoryBarControls;
+    secondaryMessage?: string | null;
+    /** Menu items for the kebab menu */
+    menuItems?: StatusBarMenuItem[];
+    /** Menu items that only appear in the mobile kebab menu. */
+    mobileMenuItems?: StatusBarMenuItem[];
+};
+export declare function EditorStatusBar({ status, lastSavedAt, toolbar, draftSyncState, onPublish, publishMenuItems, actionsSlot, toggleSlot, messageOverride, messageVariant, actionButtonSize, hasFailedSaves, onRetryFailedSaves, historyControls, secondaryMessage, menuItems, mobileMenuItems, }: EditorStatusBarProps): ReactElement;

package/dist/_dts/editor/src/chrome/statusBarPresentation.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { DraftSyncState } from '../EditorProvider';
+import type { DraftWorkflowStatus, EditorStatusBarProps, EditorStatusBarToolbar, StatusBarMenuItem } from './EditorStatusBar';
+export declare function getLatestSavedAt(values: readonly (string | null)[]): string | null;
+export type EditorStatusBarPresentationInput = Readonly<{
+    status: DraftWorkflowStatus;
+    lastSavedAt: string | null;
+    toolbar: EditorStatusBarToolbar;
+    draftSyncState: DraftSyncState;
+    hasFailedSaves: boolean;
+    errorMessage?: string | null;
+    unfinishedSummary: string | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+    onPublish?: () => Promise<void>;
+    onDiscard?: () => Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    menuItems?: StatusBarMenuItem[];
+    messageVariant: 'default' | 'manual-save';
+    actionButtonSize: 'sm' | 'default' | 'lg';
+}>;
+export declare function buildEditorStatusBarPresentationProps({ status, lastSavedAt, toolbar, draftSyncState, hasFailedSaves, errorMessage, unfinishedSummary, canUndo, canRedo, onUndo, onRedo, onPublish, onDiscard, publishMenuItems, actionsSlot, menuItems, messageVariant, actionButtonSize, }: EditorStatusBarPresentationInput): EditorStatusBarProps;

package/dist/_dts/editor/src/components/EditingToggle.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type EditingToggleProps = {
+    placement?: 'floating' | 'toolbar';
+};
+/**
+ * Toggle button for switching between edit and preview modes.
+ */
+export declare const EditingToggle: React.FC<EditingToggleProps>;
+export {};

package/dist/_dts/editor/src/hooks/useEditableElement.d.ts

@@ -0,0 +1,18 @@
+import { type KeyboardEvent } from 'react';
+export interface UseEditableElementOptions {
+    id: string;
+    value: string;
+    onChange: (value: string) => void;
+    onStartEdit?: () => void;
+    onEndEdit?: () => void;
+}
+export declare function useEditableElement({ id, onChange, onStartEdit, onEndEdit, }: UseEditableElementOptions): {
+    isEditingMode: boolean;
+    isEditing: boolean;
+    isHovered: boolean;
+    setIsHovered: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    editRef: import("react").RefObject<HTMLElement | null>;
+    handleStartEdit: () => void;
+    handleEndEdit: (newValue?: string) => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/_dts/editor/src/index.d.ts

@@ -0,0 +1,29 @@
+export { EditorChrome } from './chrome/EditorChrome';
+export { EditorStatusBar } from './chrome/EditorStatusBar';
+export { buildEditorStatusBarPresentationProps, getLatestSavedAt, } from './chrome/statusBarPresentation';
+export type { DraftWorkflowStatus, EditorHistoryBarControls, EditorStatusBarProps, EditorStatusBarToolbar, StatusBarMenuItem, } from './chrome/EditorStatusBar';
+export type { EditorStatusBarPresentationInput } from './chrome/statusBarPresentation';
+export { EditingToggle } from './components/EditingToggle';
+export { EditorProvider, useEditor } from './EditorProvider';
+export type { DraftSyncState, DrawerFocusTarget } from './EditorProvider';
+export { useEditableElement } from './hooks/useEditableElement';
+export type { UseEditableElementOptions } from './hooks/useEditableElement';
+export { InlineTextEditor } from './inline/InlineTextEditor';
+export { EditorPrimitivesProvider } from './primitives/EditorPrimitivesProvider';
+export type { InlineFieldAdapter } from './primitives/InlineFieldContext';
+export { deriveChannelId } from './primitives/helpers';
+export { richTextConfigs } from './primitives/rich-text/config';
+export type { RichTextEditorConfig, ToolbarButtonConfig, } from './primitives/rich-text/config';
+export { RichTextToolbar } from './primitives/rich-text/RichTextToolbar';
+export { RichTextEditorSurface } from './primitives/rich-text/RichTextEditorSurface';
+export type { RichTextRoutableItem } from './primitives/rich-text/toolbar/linkPopoverUtils';
+export { useRichTextEditor } from './primitives/rich-text/useRichTextEditor';
+export { buildRichTextImageAttrs, getRichTextImagePositionFromTarget, getSelectedRichTextImagePosition, insertOrReplaceRichTextImage, } from './primitives/rich-text/imageActions';
+export type { PickedRichTextImage } from './primitives/rich-text/imageActions';
+export { EMPTY_DOC, isDocEmpty, normaliseDoc, } from './primitives/rich-text/utils';
+export { formatUnsupportedRichTextSummary, hasUnsupportedRichTextContent, sanitizeRichTextContentForSchema, } from './primitives/rich-text/sanitize';
+export type { RichTextContentWarnings } from './primitives/rich-text/sanitize';
+export { EditorContent } from '@tiptap/react';
+export { EditorSaveProvider, useSaveField } from './primitives/SaveContext';
+export { createOptimisticTokenStore, OptimisticTokenStore, } from './utils/optimisticTokens';
+export type { OptimisticToken, OptimisticTokenSnapshot, } from './utils/optimisticTokens';

package/dist/_dts/editor/src/inline/InlineTextEditor.d.ts

@@ -0,0 +1 @@
+export declare const InlineTextEditor: () => import("react").JSX.Element;

package/dist/_dts/editor/src/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function cn(...values: Array<string | false | null | undefined>): string;

package/dist/_dts/editor/src/primitives/EditorPrimitivesProvider.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { type InlineFieldAdapter } from './InlineFieldContext';
+type SaveArgs = {
+    path: string;
+    value: unknown;
+};
+type SaveFieldArgs = {
+    blockId: string;
+    path: string;
+    value: unknown;
+};
+type SaveFieldFn = (args: SaveFieldArgs) => Promise<unknown>;
+export declare function EditorPrimitivesProvider({ canEdit, saveField, onSave, inlineFieldAdapter, children, }: {
+    canEdit?: boolean;
+    saveField?: SaveFieldFn;
+    onSave?: (args: SaveArgs) => Promise<void>;
+    inlineFieldAdapter?: InlineFieldAdapter | null;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export {};

package/dist/_dts/editor/src/primitives/InlineFieldContext.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+export type InlineFieldAdapter = {
+    getValue: (path: string) => unknown;
+    setValue: (path: string, value: unknown) => void;
+    subscribe: (path: string, callback: () => void) => () => void;
+};
+export declare function InlineFieldProvider({ adapter, children, }: {
+    adapter?: InlineFieldAdapter | null;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useInlineFieldAdapter(): InlineFieldAdapter | null;

package/dist/_dts/editor/src/primitives/SaveContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+type SaveArgs = {
+    path: string;
+    value: unknown;
+};
+type SaveFn = (args: SaveArgs) => Promise<void>;
+export declare function EditorSaveProvider({ save, children }: {
+    save: SaveFn;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useSaveField(): SaveFn;
+export {};

package/dist/_dts/editor/src/primitives/helpers.d.ts

@@ -0,0 +1 @@
+export declare function deriveChannelId(path: string | undefined): string | null;