@riverbankcms/sdk 0.91.0 → 0.93.0

package/dist/_dts/content-editor/src/ui/editorUiStore.d.ts

@@ -1,27 +1,27 @@
-import { type EditorUnpublishedState } from "../controller/deriveEditorUnpublishedState";
-import { type AutosaveState } from "./stores/autosaveStore";
-import { type ArrayKeysState } from "./stores/arrayKeysStore";
-import { type ViewportState } from "./stores/viewportStore";
-import { type AiOverlaysState } from "./stores/aiOverlaysSlice";
-import { type EditorValueSnapshot, type EditorBlockItem, type EditorBlockId, type NormalizedEditorBlockItem, type DraftBlockBaselineInput, type DraftBlockBaselineUpdateMetaInput, type DraftBlockInitMetaInput, type EditorCommand, type EditorContentValues, type EditorDraftSnapshot, type EditorEffect, type EditorHistorySnapshot, type EditorLinkedEntrySnapshot, type EditorMetadataValues, type BlockPublishedBaselineInput } from "./editorHistory";
-import { type HistoryState } from "./editorHistory";
-import type { FocusRequest } from "./stores/types";
-import { type LinkedContentEntryId } from "../linkedEntries/domain";
-import { type BlockDraftSaveability, type BlockDraftValidationIssue, type ResolveBlockManifest } from "./blockValidationView";
-export type { AutosaveStatusValue, AutosaveStatus, AutosaveHandle, AutosaveType, AutosaveType as AutosaveSchedulerKey, FocusRequest, ViewportMode, ViewportWidth, ZoomLevel, } from "./stores/types";
-export type { AutosaveState } from "./stores/autosaveStore";
-export type { ArrayKeysState } from "./stores/arrayKeysStore";
-export type { ViewportState } from "./stores/viewportStore";
-export type { EditorCommand, EditorBlockItem, EditorDraftSnapshot, EditorHistorySnapshot, EditorEffect, EditorLinkedEntrySnapshot, } from "./editorHistory";
+import { type EditorUnpublishedState } from '../controller/deriveEditorUnpublishedState';
+import { type AutosaveState } from './stores/autosaveStore';
+import { type ArrayKeysState } from './stores/arrayKeysStore';
+import { type ViewportState } from './stores/viewportStore';
+import { type AiOverlaysState } from './stores/aiOverlaysSlice';
+import { type EditorValueSnapshot, type EditorBlockItem, type EditorBlockId, type NormalizedEditorBlockItem, type DraftBlockBaselineInput, type DraftBlockBaselineUpdateMetaInput, type DraftBlockInitMetaInput, type EditorCommand, type EditorContentValues, type EditorDraftSnapshot, type EditorDraftUnpublishedBlockChange, type EditorEffect, type EditorHistorySnapshot, type EditorLinkedEntrySnapshot, type EditorMetadataValues, type BlockPublishedBaselineInput } from './editorHistory';
+import { type HistoryState } from './editorHistory';
+import type { FocusRequest } from './stores/types';
+import { type LinkedContentEntryId } from '../linkedEntries/domain';
+import { type BlockDraftSaveability, type BlockDraftValidationIssue, type ResolveBlockManifest } from './blockValidationView';
+export type { AutosaveStatusValue, AutosaveStatus, AutosaveHandle, AutosaveType, AutosaveType as AutosaveSchedulerKey, FocusRequest, ViewportMode, ViewportWidth, ZoomLevel, } from './stores/types';
+export type { AutosaveState } from './stores/autosaveStore';
+export type { ArrayKeysState } from './stores/arrayKeysStore';
+export type { ViewportState } from './stores/viewportStore';
+export type { EditorCommand, EditorBlockItem, EditorDraftSnapshot, EditorHistorySnapshot, EditorEffect, EditorLinkedEntrySnapshot, } from './editorHistory';
 export type MetadataSnapshot = EditorValueSnapshot<EditorMetadataValues | null>;
 export type ContentSnapshot = EditorValueSnapshot<EditorContentValues | null>;
-export type PreviewSidebarTab = "editor" | "assistant";
+export type PreviewSidebarTab = 'editor' | 'assistant';
 export type ActivePreviewField = (Readonly<{
-    kind: "block";
+    kind: 'block';
     blockId: EditorBlockId;
     fieldPath: string;
 }> | Readonly<{
-    kind: "linked-entry";
+    kind: 'linked-entry';
     entryId: LinkedContentEntryId;
     fieldPath: string;
 }>) | null;
@@ -51,17 +51,17 @@ export type MetadataState = {
     autosaveFailed: (message?: string) => void;
     clearError: () => void;
 };
-export type ContentState = Omit<MetadataState, "getSnapshot"> & {
+export type ContentState = Omit<MetadataState, 'getSnapshot'> & {
     getSnapshot: () => ContentSnapshot;
 };
 export type PreviewInspection = Readonly<{
-    kind: "none";
+    kind: 'none';
 }> | Readonly<{
-    kind: "block-customize";
+    kind: 'block-customize';
     blockId: EditorBlockId;
     requestId: number;
 }> | Readonly<{
-    kind: "linked-entry";
+    kind: 'linked-entry';
     entryId: LinkedContentEntryId;
     requestId: number;
 }>;
@@ -96,13 +96,13 @@ export type LinkedEntryState = {
 };
 export type EditorPreviewInspectorStore = {
     getState: () => {
-        drafts: Pick<DraftsState, "inspect">;
+        drafts: Pick<DraftsState, 'inspect'>;
         aiOverlays?: Readonly<{
-            viewMode: AiOverlaysState["viewMode"];
-            overrides: AiOverlaysState["overrides"];
-            structure?: AiOverlaysState["structure"];
+            viewMode: AiOverlaysState['viewMode'];
+            overrides: AiOverlaysState['overrides'];
+            structure?: AiOverlaysState['structure'];
         }>;
-        linkedEntries: Pick<LinkedEntryState, "inspect">;
+        linkedEntries: Pick<LinkedEntryState, 'inspect'>;
     };
 };
 export type EditorHistoryState = HistoryState<EditorHistorySnapshot>;
@@ -148,13 +148,7 @@ export type DraftsState = {
     getAtPath: <T = unknown>(blockId: EditorBlockId, path: string) => T | undefined;
     updateBlockOrder: (blockIds: EditorBlockId[]) => void;
     hasUnpublishedBlockChanges: () => boolean;
-    getFirstUnpublishedBlockChange: () => {
-        blockId: EditorBlockId;
-        kind: string;
-        reason: "missing_published" | "missing_current" | "different";
-        currentContent: Record<string, unknown> | null;
-        publishedContent: Record<string, unknown> | null;
-    } | null;
+    getFirstUnpublishedBlockChange: () => EditorDraftUnpublishedBlockChange | null;
     markAllBlocksAsPublished: () => void;
     onChange: (listener: (blockId: EditorBlockId) => void) => () => void;
 };
@@ -166,6 +160,18 @@ type RestoreListener = (transition: {
     next: EditorHistorySnapshot;
     effects: readonly EditorEffect[];
 }) => void;
+export type ApplyPublishSuccessTransitionInput = Readonly<{
+    metadata: Readonly<{
+        baseline: Record<string, unknown> | null;
+        current: Record<string, unknown> | null;
+        published: Record<string, unknown> | null;
+    }>;
+    content: Readonly<{
+        published: Record<string, unknown> | null;
+        versionAtPublishStart: number;
+    }>;
+    blockPublishedBaselines: readonly BlockPublishedBaselineInput[] | null;
+}>;
 export type EditorUiState = {
     drawerOpen: boolean;
     previewSidebarTab: PreviewSidebarTab;
@@ -179,12 +185,13 @@ export type EditorUiState = {
     inspectLinkedEntry: (entryId: string) => void;
     clearPreviewInspection: () => void;
     setActivePreviewField: (field: ActivePreviewField) => void;
-    requestFocus: (payload: Omit<NonNullable<FocusRequest>, "requestId">) => void;
+    requestFocus: (payload: Omit<NonNullable<FocusRequest>, 'requestId'>) => void;
     clearFocus: () => void;
     setActiveBlockId: (id: EditorBlockId | null) => void;
-    getDraftSyncState: () => "baseline" | "pending" | "failed";
+    getDraftSyncState: () => 'baseline' | 'pending' | 'failed';
     getUnpublishedState: () => EditorUnpublishedState;
     hasAnyUnpublishedChanges: () => boolean;
+    applyPublishSuccessTransition: (transition: ApplyPublishSuccessTransitionInput) => void;
     history: {
         getState: () => EditorHistoryState;
         canUndo: () => boolean;

package/dist/_dts/content-model/src/entry-slots/types.d.ts

@@ -6,6 +6,8 @@ type Brand<TValue, TBrand extends string> = TValue & {
 export type SlotKey = Brand<string, 'SlotKey'>;
 export type EntryBlockSlotId = Brand<string, 'EntryBlockSlotId'>;
 export type EntrySlotContentEntryId = Brand<string, 'EntrySlotContentEntryId'>;
+export type EntrySlotPageSurfaceId = Brand<string, 'EntrySlotPageSurfaceId'>;
+export type PageSurfaceSlotId = Brand<string, 'PageSurfaceSlotId'>;
 export type EntrySlotPageId = Brand<string, 'EntrySlotPageId'>;
 export type EntrySlotBlockId = Brand<string, 'EntrySlotBlockId'>;
 export type EntrySlotContentVersionId = Brand<string, 'EntrySlotContentVersionId'>;
@@ -41,12 +43,16 @@ export type NonEmptyStringParseError = Readonly<{
 export declare function unsafeAsSlotKey(value: string): SlotKey;
 export declare function unsafeAsEntryBlockSlotId(value: string): EntryBlockSlotId;
 export declare function unsafeAsEntrySlotContentEntryId(value: string): EntrySlotContentEntryId;
+export declare function unsafeAsEntrySlotPageSurfaceId(value: string): EntrySlotPageSurfaceId;
+export declare function unsafeAsPageSurfaceSlotId(value: string): PageSurfaceSlotId;
 export declare function unsafeAsEntrySlotPageId(value: string): EntrySlotPageId;
 export declare function unsafeAsEntrySlotBlockId(value: string): EntrySlotBlockId;
 export declare function unsafeAsEntrySlotContentVersionId(value: string): EntrySlotContentVersionId;
 export declare function unsafeAsEntrySlotBlockOrderIndex(value: number): EntrySlotBlockOrderIndex;
 export declare function parseSlotKey(value: unknown): EntrySlotResult<SlotKey, SlotKeyParseError>;
 export declare function parseEntryBlockSlotId(value: unknown): EntrySlotResult<EntryBlockSlotId, BrandedUuidParseError>;
+export declare function parseEntrySlotPageSurfaceId(value: unknown): EntrySlotResult<EntrySlotPageSurfaceId, BrandedUuidParseError>;
+export declare function parsePageSurfaceSlotId(value: unknown): EntrySlotResult<PageSurfaceSlotId, BrandedUuidParseError>;
 export declare const SYSTEM_ENTRY_SLOT_BLOCK_KIND: "system.entry-slot";
 export declare const DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS: readonly ["block.body-text", "block.rich-text", "block.image-gallery", "block.cta-full"];
 export type DefaultEntrySlotBlockKind = (typeof DEFAULT_ENTRY_SLOT_ALLOWED_BLOCKS)[number];
@@ -210,6 +216,33 @@ export type PublishedEntrySlotCompositionVersionDataV1 = Readonly<{
     blockSequence: readonly PublishedEntrySlotBlockSnapshot[];
 }>;
 export type EntrySlotCompositionVersionDataV1 = DraftEntrySlotCompositionVersionDataV1 | PublishedEntrySlotCompositionVersionDataV1;
+export type EntrySlotCompositionOwner = Readonly<{
+    kind: 'entrySlot';
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+}>;
+export type SurfaceSlotCompositionOwner = Readonly<{
+    kind: 'surfaceSlot';
+    surfaceSlotId: PageSurfaceSlotId;
+    pageSurfaceId: EntrySlotPageSurfaceId;
+}>;
+export type SlotCompositionOwner = EntrySlotCompositionOwner | SurfaceSlotCompositionOwner;
+export type DraftSlotCompositionVersionDataV2 = Readonly<{
+    schemaVersion: 2;
+    stage: 'draft';
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}>;
+export type PublishedSlotCompositionVersionDataV2 = Readonly<{
+    schemaVersion: 2;
+    stage: 'published';
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly PublishedEntrySlotBlockSnapshot[];
+}>;
+export type SlotCompositionVersionDataV2 = DraftSlotCompositionVersionDataV2 | PublishedSlotCompositionVersionDataV2;
+export type SlotCompositionVersionData = EntrySlotCompositionVersionDataV1 | SlotCompositionVersionDataV2;
 export type PublishedEntrySlotCompositionBuildError = Readonly<{
     kind: 'published-composition-contains-unpublished-block';
     blockId: EntrySlotBlockId;
@@ -221,12 +254,23 @@ export declare function buildDraftEntrySlotCompositionVersionData(input: {
     slotKey: SlotKey;
     blockSequence: readonly EntrySlotBlockSnapshot[];
 }): DraftEntrySlotCompositionVersionDataV1;
+export declare function entrySlotCompositionOwnerFromV1(versionData: EntrySlotCompositionVersionDataV1): EntrySlotCompositionOwner;
+export declare function buildDraftSlotCompositionVersionData(input: {
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): DraftSlotCompositionVersionDataV2;
 export declare function buildPublishedEntrySlotCompositionVersionData(input: {
     entrySlotId: EntryBlockSlotId;
     contentEntryId: EntrySlotContentEntryId;
     slotKey: SlotKey;
     blockSequence: readonly EntrySlotBlockSnapshot[];
 }): EntrySlotResult<PublishedEntrySlotCompositionVersionDataV1, PublishedEntrySlotCompositionBuildError>;
+export declare function buildPublishedSlotCompositionVersionData(input: {
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): EntrySlotResult<PublishedSlotCompositionVersionDataV2, PublishedEntrySlotCompositionBuildError>;
 export type EntrySlotCompositionParseError = Readonly<{
     kind: 'not-object';
 }> | Readonly<{
@@ -253,8 +297,33 @@ export type EntrySlotCompositionParseError = Readonly<{
     kind: 'published-composition-contains-unpublished-block';
     index: number;
 }>;
+export type SlotCompositionOwnerParseError = Readonly<{
+    kind: 'not-object';
+}> | Readonly<{
+    kind: 'unsupported-owner-kind';
+    ownerKind: unknown;
+}> | Readonly<{
+    kind: 'invalid-entry-slot-id';
+    error: BrandedUuidParseError | NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-surface-slot-id';
+    error: BrandedUuidParseError;
+}> | Readonly<{
+    kind: 'invalid-page-surface-id';
+    error: BrandedUuidParseError;
+}>;
+export type SlotCompositionParseError = EntrySlotCompositionParseError | Readonly<{
+    kind: 'invalid-owner';
+    error: SlotCompositionOwnerParseError;
+}>;
 export declare function parseEntrySlotCompositionVersionData(input: unknown): EntrySlotResult<EntrySlotCompositionVersionDataV1, EntrySlotCompositionParseError>;
+export declare function parseSlotCompositionVersionData(input: unknown): EntrySlotResult<SlotCompositionVersionData, SlotCompositionParseError>;
+export declare function parseSlotCompositionOwner(input: unknown): EntrySlotResult<SlotCompositionOwner, SlotCompositionOwnerParseError>;
 export declare function blockContentVersionIdsForEntrySlotCompositionVersionData(versionData: EntrySlotCompositionVersionDataV1): readonly EntrySlotContentVersionId[];
+export declare function blockContentVersionIdsForSlotCompositionVersionData(versionData: SlotCompositionVersionData): readonly EntrySlotContentVersionId[];
 export type SlotPublishPlan = Readonly<{
     kind: 'publishable';
     slotKey: SlotKey;
@@ -330,6 +399,15 @@ export declare function describeSdkEntryBlocksPatchParseError(error: SdkEntryBlo
 export type SlotContainerOwner = Readonly<{
     kind: 'contentEntry';
     contentEntryId: EntrySlotContentEntryId;
+}> | Readonly<{
+    kind: 'pageSurface';
+    pageSurfaceId: EntrySlotPageSurfaceId;
+}>;
+export type ContentEntrySlotContainerOwner = Extract<SlotContainerOwner, {
+    kind: 'contentEntry';
+}>;
+export type PageSurfaceSlotContainerOwner = Extract<SlotContainerOwner, {
+    kind: 'pageSurface';
 }>;
 export type SlotContainerOwnerParseError = Readonly<{
     kind: 'not-object';
@@ -339,10 +417,13 @@ export type SlotContainerOwnerParseError = Readonly<{
 }> | Readonly<{
     kind: 'invalid-content-entry-id';
     error: NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-page-surface-id';
+    error: BrandedUuidParseError;
 }>;
 export declare function parseSlotContainerOwner(input: unknown): EntrySlotResult<SlotContainerOwner, SlotContainerOwnerParseError>;
-export declare function slotContainerOwnerToContentVersionOwner(owner: SlotContainerOwner): ContentVersionOwner;
-export declare function slotContainerOwnerToEntrySlotLookup(owner: SlotContainerOwner): Readonly<{
+export declare function slotContainerOwnerToContentVersionOwner(owner: ContentEntrySlotContainerOwner): ContentVersionOwner;
+export declare function slotContainerOwnerToEntrySlotLookup(owner: ContentEntrySlotContainerOwner): Readonly<{
     contentEntryId: EntrySlotContentEntryId;
 }>;
 export type PlannedSlotCompositionBlockWrite = Readonly<{
@@ -401,6 +482,33 @@ export type EditableBlockOwner = Readonly<{
     kind: 'entry-slot';
     entrySlotId: EntryBlockSlotId;
 }>;
+export type SlotCompositionTransferReviewReason = Readonly<{
+    kind: 'target-is-not-surface-slot';
+    targetKind: SlotCompositionOwner['kind'];
+}>;
+export type SlotCompositionTransferPlan = Readonly<{
+    kind: 'noChange';
+    owner: SlotCompositionOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'copyEntrySlotToSurfaceSlot';
+    from: EntrySlotCompositionOwner;
+    to: SurfaceSlotCompositionOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'forkSurfaceSlotComposition';
+    from: SurfaceSlotCompositionOwner;
+    to: SurfaceSlotCompositionOwner;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'manualReviewRequired';
+    reason: SlotCompositionTransferReviewReason;
+}>;
+export declare function planSlotCompositionTransfer(input: Readonly<{
+    from: SlotCompositionOwner;
+    to: SlotCompositionOwner;
+    slotKey: SlotKey;
+}>): SlotCompositionTransferPlan;
 export type EntryLifecycleRecoveryCheckpoint = 'entry-fields' | 'route-metadata' | 'slot-composition' | 'block-published-refs' | 'cache-revalidation';
 export type EntryLifecycleCommitPlan = Readonly<{
     kind: 'transactional-commit';

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

@@ -28,6 +28,7 @@ export type SiteRouteId = Brand<string, 'SiteRouteId'>;
 export type PageId = Brand<string, 'PageId'>;
 export type PageSurfaceId = Brand<string, 'PageSurfaceId'>;
 export type OccurrenceId = Brand<string, 'OccurrenceId'>;
+export type EventOfferingId = Brand<string, 'EventOfferingId'>;
 export type EventSeriesId = Brand<string, 'EventSeriesId'>;
 export type TicketTypeId = Brand<string, 'TicketTypeId'>;
 export type EventCategoryId = Brand<string, 'EventCategoryId'>;
@@ -143,6 +144,7 @@ export declare const unsafeAsSiteRouteId: (id: string) => SiteRouteId;
 export declare const unsafeAsPageId: (id: string) => PageId;
 export declare const unsafeAsPageSurfaceId: (id: string) => PageSurfaceId;
 export declare const unsafeAsOccurrenceId: (id: string) => OccurrenceId;
+export declare const unsafeAsEventOfferingId: (id: string) => EventOfferingId;
 export declare const unsafeAsEventSeriesId: (id: string) => EventSeriesId;
 export declare const unsafeAsTicketTypeId: (id: string) => TicketTypeId;
 export declare const unsafeAsEventCategoryId: (id: string) => EventCategoryId;
@@ -232,6 +234,7 @@ export declare const parseSiteRouteId: (value: unknown) => Result<SiteRouteId, B
 export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdParseError>;
 export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;
 export declare const parseOccurrenceId: (value: unknown) => Result<OccurrenceId, BrandedIdParseError>;
+export declare const parseEventOfferingId: (value: unknown) => Result<EventOfferingId, BrandedIdParseError>;
 export declare const parseTicketTypeId: (value: unknown) => Result<TicketTypeId, BrandedIdParseError>;
 export declare const parsePricingOptionId: (value: unknown) => Result<PricingOptionId, BrandedIdParseError>;
 export declare const parseUserId: (value: unknown) => Result<UserId, BrandedIdParseError>;

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

@@ -1,5 +1,5 @@
 import { type CurrencyDecimals } from "./currency-format";
-export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types"];
+export declare const EVENT_PRICING_MODES: readonly ["single", "ticket_types", "sliding_scale"];
 export type EventPricingMode = (typeof EVENT_PRICING_MODES)[number];
 export type PublicEventPricingType = "free" | "paid" | "external";
 export type PublicCoursePriceDisplay = Readonly<{
@@ -13,6 +13,11 @@ export type PublicCoursePriceDisplay = Readonly<{
     kind: "from";
     amount: number;
     currency: string;
+}> | Readonly<{
+    kind: "range";
+    minAmount: number;
+    maxAmount: number;
+    currency: string;
 }> | Readonly<{
     kind: "unavailable";
     currency: string;
@@ -70,6 +75,18 @@ export type PublicEventPricing<TTicketType = never> = Readonly<{
     currency: string;
     ticketTypes: readonly TTicketType[];
     display: PublicEventTicketTypePriceDisplay;
+}> | Readonly<{
+    kind: "sliding_scale";
+    minAmount: number;
+    maxAmount: number;
+    suggestedAmount: number | null;
+    currency: string;
+    display: Readonly<{
+        kind: "range";
+        minAmount: number;
+        maxAmount: number;
+        currency: string;
+    }>;
 }> | Readonly<{
     kind: "course";
     display: Readonly<{

package/dist/_dts/core/src/money-input.d.ts

@@ -1,7 +1,8 @@
 import type { Brand } from './branded';
 import { type Result } from './result';
-export type PositiveMoneyCents = Brand<number, 'PositiveMoneyCents'>;
-export type NonNegativeMoneyCents = Brand<number, 'NonNegativeMoneyCents'>;
+export type Cents = Brand<number, 'Cents'>;
+export type NonNegativeCents = Brand<number, 'NonNegativeCents'>;
+export type PositiveCents = Brand<number, 'PositiveCents'>;
 export type MoneyInputParseError = Readonly<{
     kind: 'empty';
 }> | Readonly<{
@@ -11,6 +12,15 @@ export type MoneyInputParseError = Readonly<{
 }> | Readonly<{
     kind: 'zero-not-allowed';
 }>;
+export type CentsParseError = Readonly<{
+    kind: 'invalid-number';
+}> | Readonly<{
+    kind: 'not-whole-cents';
+}> | Readonly<{
+    kind: 'negative';
+}> | Readonly<{
+    kind: 'zero-not-allowed';
+}>;
 export type ParseMoneyInputToCentsOptions = Readonly<{
     allowZero?: boolean;
     stripFormatting?: boolean;
@@ -18,7 +28,27 @@ export type ParseMoneyInputToCentsOptions = Readonly<{
 export type ParseStrictMoneyInputToCentsOptions = Readonly<{
     stripFormatting?: boolean;
 }>;
-export declare function parsePositiveMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<PositiveMoneyCents, MoneyInputParseError>;
-export declare function parseNonNegativeMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<NonNegativeMoneyCents, MoneyInputParseError>;
+export declare function unsafeAsCents(value: number): Cents;
+export declare function unsafeAsNonNegativeCents(value: number): NonNegativeCents;
+export declare function unsafeAsPositiveCents(value: number): PositiveCents;
+export declare function unwrapCents(value: Cents): number;
+export declare function isWholeCents(value: number): boolean;
+export declare function isNonNegativeWholeCents(value: number): boolean;
+export declare function isPositiveWholeCents(value: number): boolean;
+/**
+ * Normalizes a derived amount to signed whole cents. Use parse*Cents for
+ * untrusted input that should fail instead of truncating or clamping.
+ */
+export declare function toCents(value: number): Cents;
+/**
+ * Normalizes a derived amount to non-negative whole cents. This intentionally
+ * clamps negatives to zero; use parseNonNegativeCents for validation.
+ */
+export declare function toNonNegativeCents(value: number): NonNegativeCents;
+export declare function parseCents(value: number): Result<Cents, CentsParseError>;
+export declare function parseNonNegativeCents(value: number): Result<NonNegativeCents, CentsParseError>;
+export declare function parsePositiveCents(value: number): Result<PositiveCents, CentsParseError>;
+export declare function parsePositiveMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<PositiveCents, MoneyInputParseError>;
+export declare function parseNonNegativeMoneyInputToCents(value: string, options?: ParseStrictMoneyInputToCentsOptions): Result<NonNegativeCents, MoneyInputParseError>;
 export declare function parseMoneyInputToCents(value: string, options?: ParseMoneyInputToCentsOptions): number | null;
 export declare function formatMoneyInputFromCents(amountCents: number | null | undefined): string;

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

@@ -3309,6 +3309,9 @@ export type Database = {
                     pricing_strategy: string;
                     single_price_amount: number | null;
                     site_id: string;
+                    sliding_max_amount: number | null;
+                    sliding_min_amount: number | null;
+                    sliding_suggested_amount: number | null;
                     updated_at: string;
                 };
                 Insert: {
@@ -3323,6 +3326,9 @@ export type Database = {
                     pricing_strategy: string;
                     single_price_amount?: number | null;
                     site_id: string;
+                    sliding_max_amount?: number | null;
+                    sliding_min_amount?: number | null;
+                    sliding_suggested_amount?: number | null;
                     updated_at?: string;
                 };
                 Update: {
@@ -3337,6 +3343,9 @@ export type Database = {
                     pricing_strategy?: string;
                     single_price_amount?: number | null;
                     site_id?: string;
+                    sliding_max_amount?: number | null;
+                    sliding_min_amount?: number | null;
+                    sliding_suggested_amount?: number | null;
                     updated_at?: string;
                 };
                 Relationships: [
@@ -11529,6 +11538,67 @@ export type Database = {
                     }
                 ];
             };
+            page_surface_slots: {
+                Row: {
+                    created_at: string;
+                    created_by: string | null;
+                    deleted_at: string | null;
+                    deleted_by: string | null;
+                    id: string;
+                    page_surface_id: string;
+                    site_id: string;
+                    slot_key: string;
+                    updated_at: string;
+                    updated_by: string | null;
+                };
+                Insert: {
+                    created_at?: string;
+                    created_by?: string | null;
+                    deleted_at?: string | null;
+                    deleted_by?: string | null;
+                    id?: string;
+                    page_surface_id: string;
+                    site_id: string;
+                    slot_key: string;
+                    updated_at?: string;
+                    updated_by?: string | null;
+                };
+                Update: {
+                    created_at?: string;
+                    created_by?: string | null;
+                    deleted_at?: string | null;
+                    deleted_by?: string | null;
+                    id?: string;
+                    page_surface_id?: string;
+                    site_id?: string;
+                    slot_key?: string;
+                    updated_at?: string;
+                    updated_by?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "page_surface_slots_page_surface_id_fkey";
+                        columns: ["page_surface_id"];
+                        isOneToOne: false;
+                        referencedRelation: "page_surfaces";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "page_surface_slots_site_id_fkey";
+                        columns: ["site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sites";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "page_surface_slots_surface_site_fk";
+                        columns: ["page_surface_id", "site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "page_surfaces";
+                        referencedColumns: ["id", "site_id"];
+                    }
+                ];
+            };
             page_surfaces: {
                 Row: {
                     created_at: string;

package/dist/_dts/media-core/src/fileAssetCompatibility.d.ts

@@ -9,7 +9,7 @@ import type { MediaAsset, MediaSource } from './types';
  * Until then it keeps old image/video rows readable through the new typed model without
  * changing current storage or DB behavior.
  */
-export type LegacyMediaAssetProjectionError = 'unsupported-mime-type' | 'non-renderable-legacy-media-kind' | 'empty-site-id' | 'empty-storage-bucket' | 'empty-storage-path' | 'empty-filename' | 'invalid-byte-count' | 'invalid-checksum' | 'invalid-created-at' | 'invalid-updated-at';
+export type LegacyMediaAssetProjectionError = 'unsupported-mime-type' | 'non-renderable-legacy-media-kind' | 'empty-site-id' | 'empty-storage-bucket' | 'empty-storage-path' | 'empty-filename' | 'invalid-storage-path' | 'invalid-byte-count' | 'invalid-checksum' | 'invalid-created-at' | 'invalid-updated-at';
 export declare function projectLegacyMediaAssetToFileAsset(asset: MediaAsset): Result<FileAsset, LegacyMediaAssetProjectionError>;
 export declare function fileAssetSourceFromLegacyMediaSource(source: MediaSource): FileAssetSource;
 export declare function deriveLegacyMediaAssetDerivatives(asset: MediaAsset, kind: FileKind): readonly FileDerivative[];

package/dist/_dts/media-core/src/filePersistence.d.ts

@@ -1,5 +1,6 @@
 import { type DeclaredMimeType, type DetectedMimeType, type FileChecksumSha256, type NonEmptyArray, type OriginalFilename, type PositiveByteCount, type Result, type SafeDownloadFilename, type SiteId, type StorageBucketName, type StoragePath, type UploadSessionId, type UserId, type UtcIsoDateTimeString } from '../../core/src/index';
 import { type AccessPolicy, type ActiveFileAssetValidationError, type ActiveValidatedFileAsset, type FileAsset, type FileActor, type FileDerivative, type FileKind, type FileUse, type StorageClass, type UploadSessionState, type UploadSessionStateTag, type UploadIntent, type UploadPolicy, type UploadPolicyDetection } from './fileDomain';
+import { type FileStoragePathError } from './fileStorage';
 export type FileKindJson = FileJsonObject;
 export type FileUseJson = FileJsonObject;
 export type FileUsesJson = readonly FileUseJson[];
@@ -8,7 +9,7 @@ export type UploadIntentJson = FileJsonObject;
 export type AccessPolicyJson = FileJsonObject;
 export type UploadPolicyJson = FileJsonObject;
 export type FileDomainJson = FileJsonObject | readonly FileJsonValue[];
-export type FileDomainJsonParseError = 'expected-object' | 'expected-array' | 'expected-non-empty-array' | 'invalid-tag' | 'invalid-field' | 'invalid-string' | 'invalid-number' | 'invalid-positive-byte-count' | 'invalid-positive-seconds' | 'invalid-timestamp' | 'invalid-checksum' | 'invalid-safe-download-filename' | 'missing-state-timestamp' | 'missing-finalized-asset' | 'missing-rejection-reason';
+export type FileDomainJsonParseError = 'expected-object' | 'expected-array' | 'expected-non-empty-array' | 'invalid-tag' | 'invalid-field' | 'invalid-string' | 'invalid-number' | 'invalid-positive-byte-count' | 'invalid-positive-seconds' | 'invalid-timestamp' | 'invalid-checksum' | 'invalid-safe-download-filename' | 'invalid-storage-path' | 'missing-state-timestamp' | 'missing-finalized-asset' | 'missing-rejection-reason';
 export type FileUploadSessionRecordError = 'actor-site-mismatch' | 'policy-intent-mismatch';
 export type FileJsonValue = string | number | boolean | null | FileJsonObject | readonly FileJsonValue[];
 export type FileJsonObject = {
@@ -179,6 +180,9 @@ export type FileAssetRowParseError = {
 } | {
     readonly tag: 'invalid-derivative-kind';
     readonly error: FileDomainJsonParseError;
+} | {
+    readonly tag: 'invalid-storage-path';
+    readonly error: FileStoragePathError;
 } | {
     readonly tag: 'invalid-file-asset';
     readonly error: ActiveFileAssetValidationError;

package/dist/_dts/media-core/src/fileStorage.d.ts

@@ -38,3 +38,4 @@ export declare function buildStagedUploadStoragePath(input: StagedUploadStorageP
  * `sites/{siteId}/files/{fileAssetId}/{safeDownloadFilename}`.
  */
 export declare function buildDurableFileStoragePath(input: DurableFileStoragePathInput): Result<SiteScopedStoragePath, FileStoragePathError>;
+export declare function parseStoragePath(value: string): Result<StoragePath, FileStoragePathError>;

package/dist/_dts/media-core/src/fileUploadFinalization.d.ts

@@ -13,7 +13,35 @@ export type FinalizableFileUploadSessionRecord = Omit<FileUploadSessionRecord, '
 export type FinalizedFileUploadSessionRecord = Omit<FileUploadSessionRecord, 'state'> & {
     readonly state: FinalizedUploadSessionState;
 };
-export type FileUploadFinalizationError = 'checksum-mismatch' | 'checksum-missing' | 'declared-detected-mime-mismatch' | 'file-too-large' | 'kind-not-allowed' | 'policy-intent-mismatch' | 'storage-bucket-mismatch' | 'storage-path-mismatch' | 'upload-session-expired' | 'upload-session-not-finalizable' | 'unsupported-declared-mime-type' | 'unsupported-detected-mime-type';
+export type FileUploadFinalizationError = {
+    readonly tag: 'checksum-mismatch';
+} | {
+    readonly tag: 'checksum-missing';
+} | {
+    readonly tag: 'declared-detected-mime-mismatch';
+    readonly declaredMimeType: DeclaredMimeType;
+    readonly detectedMimeType: DetectedMimeType;
+    readonly declaredKind: FileKind;
+    readonly detectedKind: FileKind;
+} | {
+    readonly tag: 'file-too-large';
+} | {
+    readonly tag: 'kind-not-allowed';
+} | {
+    readonly tag: 'policy-intent-mismatch';
+} | {
+    readonly tag: 'storage-bucket-mismatch';
+} | {
+    readonly tag: 'storage-path-mismatch';
+} | {
+    readonly tag: 'upload-session-expired';
+} | {
+    readonly tag: 'upload-session-not-finalizable';
+} | {
+    readonly tag: 'unsupported-declared-mime-type';
+} | {
+    readonly tag: 'unsupported-detected-mime-type';
+};
 export type FileUploadFinalizationInput = {
     readonly uploadSession: FileUploadSessionRecord;
     readonly requestedStorageBucket: StorageBucketName;

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

@@ -43,3 +43,4 @@ export * from './richTextImageWriteNormalizer';
 export * from './mediaUsageProjection';
 export * from './portableMediaReferences';
 export * from './renderableMediaAsset';
+export * from './legacyMediaValue';

package/dist/_dts/media-core/src/legacyMediaValue.d.ts

@@ -0,0 +1,11 @@
+export type LegacyStringMediaFieldConfig = Readonly<{
+    type: 'media' | 'file';
+    mediaKinds?: readonly string[] | null;
+    fileKinds?: readonly string[] | null;
+}>;
+export type LegacyStringMediaValue = Readonly<{
+    type: string;
+    src: string;
+}>;
+export declare function legacyStringMediaTypeForField(field: LegacyStringMediaFieldConfig): string;
+export declare function normalizeLegacyStringMediaValueForField(value: unknown, field: LegacyStringMediaFieldConfig): unknown;