@riverbankcms/sdk 0.81.0 → 0.84.0

package/dist/_dts/content-editor/src/primitives/shared/types.d.ts

@@ -1,4 +1,5 @@
 import type { EditorBlockId } from '../../ui/editorHistory';
+import type { LinkedContentEntryId } from '../../linkedEntries/domain';
 /**
  * Path information for store binding.
  * Supports three patterns:
@@ -16,4 +17,8 @@ export type PathInfo = {
 } | {
     store: 'metadata';
     field: string;
+} | {
+    store: 'linkedEntry';
+    entryId: LinkedContentEntryId;
+    field: string;
 };

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

@@ -16,10 +16,15 @@ export type { EditorCommand, EditorBlockItem, EditorDraftSnapshot, EditorHistory
 export type MetadataSnapshot = EditorValueSnapshot<EditorMetadataValues | null>;
 export type ContentSnapshot = EditorValueSnapshot<EditorContentValues | null>;
 export type PreviewSidebarTab = "editor" | "assistant";
-export type ActivePreviewField = Readonly<{
+export type ActivePreviewField = (Readonly<{
+    kind: "block";
     blockId: EditorBlockId;
     fieldPath: string;
-}> | null;
+}> | Readonly<{
+    kind: "linked-entry";
+    entryId: LinkedContentEntryId;
+    fieldPath: string;
+}>) | null;
 /**
  * Version of the local draft snapshot that a completed autosave request persisted.
  * The reducer uses this to accept the saved baseline without treating older

package/dist/_dts/content-model/src/content-types/builtin-schemas.d.ts

@@ -65,21 +65,6 @@ export declare const EVENT_CONTENT_TYPE_SCHEMA: {
         readonly type: "media";
         readonly label: "Listing image";
         readonly description: "Optional image used for event cards and previews.";
-    }, {
-        readonly id: "tags";
-        readonly type: "text";
-        readonly label: "Tags";
-        readonly description: "Comma-separated tags for event listings.";
-    }, {
-        readonly id: "badges";
-        readonly type: "text";
-        readonly label: "Badges";
-        readonly description: "Comma-separated badges shown on event cards.";
-    }, {
-        readonly id: "ctaLabel";
-        readonly type: "text";
-        readonly label: "CTA label";
-        readonly description: "Optional call-to-action label for event cards.";
     }, {
         readonly id: "body";
         readonly type: "richText";
@@ -115,21 +100,6 @@ export declare const COURSE_CONTENT_TYPE_SCHEMA: {
         readonly type: "media";
         readonly label: "Listing image";
         readonly description: "Optional image used for course cards and previews.";
-    }, {
-        readonly id: "tags";
-        readonly type: "text";
-        readonly label: "Tags";
-        readonly description: "Comma-separated tags for course listings.";
-    }, {
-        readonly id: "badges";
-        readonly type: "text";
-        readonly label: "Badges";
-        readonly description: "Comma-separated badges shown on course cards.";
-    }, {
-        readonly id: "ctaLabel";
-        readonly type: "text";
-        readonly label: "CTA label";
-        readonly description: "Optional call-to-action label for course cards.";
     }, {
         readonly id: "body";
         readonly type: "richText";
@@ -222,16 +192,6 @@ export declare const PRODUCT_CONTENT_TYPE_SCHEMA: {
         readonly type: "media";
         readonly label: "Listing image";
         readonly description: "Optional image used for product cards and previews.";
-    }, {
-        readonly id: "badges";
-        readonly type: "text";
-        readonly label: "Badges";
-        readonly description: "Comma-separated badges shown on product cards.";
-    }, {
-        readonly id: "ctaLabel";
-        readonly type: "text";
-        readonly label: "CTA label";
-        readonly description: "Optional call-to-action label for product cards.";
     }, {
         readonly id: "body";
         readonly type: "richText";

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

@@ -182,21 +182,6 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly type: "media";
             readonly label: "Listing image";
             readonly description: "Optional image used for event cards and previews.";
-        }, {
-            readonly id: "tags";
-            readonly type: "text";
-            readonly label: "Tags";
-            readonly description: "Comma-separated tags for event listings.";
-        }, {
-            readonly id: "badges";
-            readonly type: "text";
-            readonly label: "Badges";
-            readonly description: "Comma-separated badges shown on event cards.";
-        }, {
-            readonly id: "ctaLabel";
-            readonly type: "text";
-            readonly label: "CTA label";
-            readonly description: "Optional call-to-action label for event cards.";
         }, {
             readonly id: "body";
             readonly type: "richText";
@@ -232,21 +217,6 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly type: "media";
             readonly label: "Listing image";
             readonly description: "Optional image used for course cards and previews.";
-        }, {
-            readonly id: "tags";
-            readonly type: "text";
-            readonly label: "Tags";
-            readonly description: "Comma-separated tags for course listings.";
-        }, {
-            readonly id: "badges";
-            readonly type: "text";
-            readonly label: "Badges";
-            readonly description: "Comma-separated badges shown on course cards.";
-        }, {
-            readonly id: "ctaLabel";
-            readonly type: "text";
-            readonly label: "CTA label";
-            readonly description: "Optional call-to-action label for course cards.";
         }, {
             readonly id: "body";
             readonly type: "richText";
@@ -339,16 +309,6 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly type: "media";
             readonly label: "Listing image";
             readonly description: "Optional image used for product cards and previews.";
-        }, {
-            readonly id: "badges";
-            readonly type: "text";
-            readonly label: "Badges";
-            readonly description: "Comma-separated badges shown on product cards.";
-        }, {
-            readonly id: "ctaLabel";
-            readonly type: "text";
-            readonly label: "CTA label";
-            readonly description: "Optional call-to-action label for product cards.";
         }, {
             readonly id: "body";
             readonly type: "richText";

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

@@ -0,0 +1 @@
+export * from './types';

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

@@ -0,0 +1,356 @@
+import type { TemplateBlockDefinition, TemplateDefinition } from '../templates/types';
+declare const __entrySlotBrand: unique symbol;
+type Brand<TValue, TBrand extends string> = TValue & {
+    readonly [__entrySlotBrand]: TBrand;
+};
+export type SlotKey = Brand<string, 'SlotKey'>;
+export type EntryBlockSlotId = Brand<string, 'EntryBlockSlotId'>;
+export type EntrySlotContentEntryId = Brand<string, 'EntrySlotContentEntryId'>;
+export type EntrySlotPageId = Brand<string, 'EntrySlotPageId'>;
+export type EntrySlotBlockId = Brand<string, 'EntrySlotBlockId'>;
+export type EntrySlotContentVersionId = Brand<string, 'EntrySlotContentVersionId'>;
+export type EntrySlotBlockOrderIndex = Brand<number, 'EntrySlotBlockOrderIndex'>;
+export type EntrySlotResult<TValue, TError> = Readonly<{
+    ok: true;
+    value: TValue;
+}> | Readonly<{
+    ok: false;
+    error: TError;
+}>;
+export type SlotKeyParseError = Readonly<{
+    kind: 'not-string';
+}> | Readonly<{
+    kind: 'empty';
+}> | Readonly<{
+    kind: 'invalid-format';
+    value: string;
+}>;
+export type BrandedUuidParseError = Readonly<{
+    kind: 'not-string';
+}> | Readonly<{
+    kind: 'empty';
+}> | Readonly<{
+    kind: 'invalid-uuid';
+    value: string;
+}>;
+export type NonEmptyStringParseError = Readonly<{
+    kind: 'not-string';
+}> | Readonly<{
+    kind: 'empty';
+}>;
+export declare function unsafeAsSlotKey(value: string): SlotKey;
+export declare function unsafeAsEntryBlockSlotId(value: string): EntryBlockSlotId;
+export declare function unsafeAsEntrySlotContentEntryId(value: string): EntrySlotContentEntryId;
+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 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];
+export type EntrySlotAllowedBlocks = Readonly<{
+    kind: 'default';
+    blockKinds: readonly DefaultEntrySlotBlockKind[];
+}> | Readonly<{
+    kind: 'restricted';
+    blockKinds: readonly string[];
+}> | Readonly<{
+    kind: 'none';
+    blockKinds: readonly [];
+}>;
+export type EntrySlotDefinition = Readonly<{
+    slotKey: SlotKey;
+    label: string;
+    allowedBlocks: EntrySlotAllowedBlocks;
+}>;
+export type EntrySlotDefinitionParseError = Readonly<{
+    kind: 'invalid-slot-scope';
+    blockIndex: number;
+    scope: TemplateBlockDefinition['scope'];
+}> | Readonly<{
+    kind: 'invalid-slot-content';
+    blockIndex: number;
+}> | Readonly<{
+    kind: 'invalid-slot-key';
+    blockIndex: number;
+    error: SlotKeyParseError;
+}> | Readonly<{
+    kind: 'missing-label';
+    blockIndex: number;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'invalid-allowed-blocks';
+    blockIndex: number;
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'invalid-allowed-block-kind';
+    blockIndex: number;
+    slotKey: SlotKey;
+    value: unknown;
+}> | Readonly<{
+    kind: 'template-only-block-kind';
+    blockIndex: number;
+    slotKey: SlotKey;
+    blockKind: string;
+}> | Readonly<{
+    kind: 'duplicate-allowed-block-kind';
+    blockIndex: number;
+    slotKey: SlotKey;
+    blockKind: string;
+}> | Readonly<{
+    kind: 'duplicate-slot-key';
+    slotKey: SlotKey;
+    firstBlockIndex: number;
+    blockIndex: number;
+}>;
+export declare function parseEntrySlotDefinitions(template: Pick<TemplateDefinition, 'blocks'>): EntrySlotResult<readonly EntrySlotDefinition[], EntrySlotDefinitionParseError>;
+export declare function isEntrySlotTemplateBlock(block: TemplateBlockDefinition): block is TemplateBlockDefinition & Readonly<{
+    blockKind: typeof SYSTEM_ENTRY_SLOT_BLOCK_KIND;
+}>;
+export type EntrySlotBlockKindValidationError = Readonly<{
+    kind: 'template-only-block-kind';
+    blockKind: string;
+}> | Readonly<{
+    kind: 'block-kind-not-allowed';
+    blockKind: string;
+    slotKey: SlotKey;
+}>;
+export declare function validateBlockKindForEntrySlot(definition: EntrySlotDefinition, blockKind: string): EntrySlotResult<string, EntrySlotBlockKindValidationError>;
+export type StoredEntrySlotSummary = Readonly<{
+    entrySlotId: EntryBlockSlotId;
+    slotKey: SlotKey;
+    draftCompositionVersionId: EntrySlotContentVersionId | null;
+    publishedCompositionVersionId: EntrySlotContentVersionId | null;
+}>;
+export type DefinedEntrySlot = Readonly<{
+    kind: 'defined';
+    definition: EntrySlotDefinition;
+    entrySlot: StoredEntrySlotSummary | null;
+}>;
+export type OrphanedEntrySlot = Readonly<{
+    kind: 'orphaned';
+    slotKey: SlotKey;
+    entrySlot: StoredEntrySlotSummary;
+}>;
+export type VisibleEntrySlot = DefinedEntrySlot | OrphanedEntrySlot;
+export type EntryPageCompositionState = Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'draft-only';
+    draftCompositionVersionId: EntrySlotContentVersionId;
+}> | Readonly<{
+    kind: 'published-only';
+    publishedCompositionVersionId: EntrySlotContentVersionId;
+}> | Readonly<{
+    kind: 'draft-and-published';
+    draftCompositionVersionId: EntrySlotContentVersionId;
+    publishedCompositionVersionId: EntrySlotContentVersionId;
+}> | Readonly<{
+    kind: 'invalid';
+    reason: 'orphaned-slot' | 'missing-slot-definition';
+}>;
+export declare function resolveEntrySlotVisibility(input: {
+    definitions: readonly EntrySlotDefinition[];
+    storedSlots: readonly StoredEntrySlotSummary[];
+}): readonly VisibleEntrySlot[];
+export declare function resolveEntryPageCompositionState(slot: VisibleEntrySlot): EntryPageCompositionState;
+export type EntrySlotBlockSource<TBlock> = Readonly<{
+    slotKey: SlotKey | string;
+    blocks: readonly TBlock[];
+}>;
+export declare function selectBlocksForDeclaredEntrySlot<TBlock>(input: {
+    declaredSlotKey: SlotKey;
+    entrySlots: readonly EntrySlotBlockSource<TBlock>[];
+}): readonly TBlock[];
+export type MissingEntrySlotBlockContentReason = 'new-block' | 'deleted-content-version' | 'unpublished-block';
+export type PublishedEntrySlotBlockSnapshot = Readonly<{
+    kind: 'published-block-content';
+    blockId: EntrySlotBlockId;
+    contentVersionId: EntrySlotContentVersionId;
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    orderIndex: EntrySlotBlockOrderIndex;
+}>;
+export type DraftEntrySlotBlockSnapshot = Readonly<{
+    kind: 'draft-block-content';
+    blockId: EntrySlotBlockId;
+    contentVersionId: EntrySlotContentVersionId | null;
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    orderIndex: EntrySlotBlockOrderIndex;
+}>;
+export type MissingEntrySlotBlockSnapshot = Readonly<{
+    kind: 'missing-block-content';
+    blockId: EntrySlotBlockId;
+    identifier: string | null;
+    blockKind: string;
+    purpose: string;
+    orderIndex: EntrySlotBlockOrderIndex;
+    reason: MissingEntrySlotBlockContentReason;
+}>;
+export type EntrySlotBlockSnapshot = PublishedEntrySlotBlockSnapshot | DraftEntrySlotBlockSnapshot | MissingEntrySlotBlockSnapshot;
+export type DraftEntrySlotCompositionVersionDataV1 = Readonly<{
+    schemaVersion: 1;
+    stage: 'draft';
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}>;
+export type PublishedEntrySlotCompositionVersionDataV1 = Readonly<{
+    schemaVersion: 1;
+    stage: 'published';
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly PublishedEntrySlotBlockSnapshot[];
+}>;
+export type EntrySlotCompositionVersionDataV1 = DraftEntrySlotCompositionVersionDataV1 | PublishedEntrySlotCompositionVersionDataV1;
+export type PublishedEntrySlotCompositionBuildError = Readonly<{
+    kind: 'published-composition-contains-unpublished-block';
+    blockId: EntrySlotBlockId;
+    snapshotKind: Exclude<EntrySlotBlockSnapshot['kind'], 'published-block-content'>;
+}>;
+export declare function buildDraftEntrySlotCompositionVersionData(input: {
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): DraftEntrySlotCompositionVersionDataV1;
+export declare function buildPublishedEntrySlotCompositionVersionData(input: {
+    entrySlotId: EntryBlockSlotId;
+    contentEntryId: EntrySlotContentEntryId;
+    slotKey: SlotKey;
+    blockSequence: readonly EntrySlotBlockSnapshot[];
+}): EntrySlotResult<PublishedEntrySlotCompositionVersionDataV1, PublishedEntrySlotCompositionBuildError>;
+export type EntrySlotCompositionParseError = Readonly<{
+    kind: 'not-object';
+}> | Readonly<{
+    kind: 'unsupported-schema-version';
+    schemaVersion: unknown;
+}> | Readonly<{
+    kind: 'invalid-stage';
+    stage: unknown;
+}> | Readonly<{
+    kind: 'invalid-entry-slot-id';
+    error: BrandedUuidParseError | NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-content-entry-id';
+    error: NonEmptyStringParseError;
+}> | Readonly<{
+    kind: 'invalid-slot-key';
+    error: SlotKeyParseError;
+}> | Readonly<{
+    kind: 'invalid-block-sequence';
+}> | Readonly<{
+    kind: 'invalid-block-snapshot';
+    index: number;
+}> | Readonly<{
+    kind: 'published-composition-contains-unpublished-block';
+    index: number;
+}>;
+export declare function parseEntrySlotCompositionVersionData(input: unknown): EntrySlotResult<EntrySlotCompositionVersionDataV1, EntrySlotCompositionParseError>;
+export declare function blockContentVersionIdsForEntrySlotCompositionVersionData(versionData: EntrySlotCompositionVersionDataV1): readonly EntrySlotContentVersionId[];
+export type SlotPublishPlan = Readonly<{
+    kind: 'publishable';
+    slotKey: SlotKey;
+    needsBlockContentPublish: boolean;
+}> | Readonly<{
+    kind: 'blocked';
+    slotKey: SlotKey;
+    reason: 'missing-block-content';
+    blockIds: readonly EntrySlotBlockId[];
+}> | Readonly<{
+    kind: 'warning-only';
+    slotKey: SlotKey;
+    warning: 'orphaned-slot-hidden';
+}>;
+export declare function planEntrySlotPublish(input: {
+    slot: VisibleEntrySlot;
+    draftBlockSequence: readonly EntrySlotBlockSnapshot[];
+}): SlotPublishPlan;
+export type SlotDiscardPlan = Readonly<{
+    kind: 'discardable';
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'skip-hidden-orphan';
+    slotKey: SlotKey;
+}>;
+export declare function planEntrySlotDiscard(slot: VisibleEntrySlot): SlotDiscardPlan;
+export type SdkEntryBlocksPatch = Readonly<{
+    kind: 'leave-unchanged';
+}> | Readonly<{
+    kind: 'patch-slots';
+    slots: readonly SdkEntrySlotBlocksPatch[];
+}>;
+export type SdkEntrySlotBlocksPatch = Readonly<{
+    kind: 'clear-slot';
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'replace-slot';
+    slotKey: SlotKey;
+    blocks: readonly SdkEntrySlotBlockInput[];
+}>;
+export type SdkEntrySlotBlockInput = Readonly<{
+    identifier: string | null;
+    kind: string;
+    content: Record<string, unknown>;
+}>;
+export type SdkEntryBlocksPatchParseError = Readonly<{
+    kind: 'invalid-blocks-object';
+}> | Readonly<{
+    kind: 'invalid-slot-key';
+    key: string;
+    error: SlotKeyParseError;
+}> | Readonly<{
+    kind: 'invalid-slot-blocks';
+    slotKey: SlotKey;
+}> | Readonly<{
+    kind: 'invalid-block';
+    slotKey: SlotKey;
+    blockIndex: number;
+}> | Readonly<{
+    kind: 'template-only-block-kind';
+    slotKey: SlotKey;
+    blockIndex: number;
+    blockKind: string;
+}>;
+export declare function parseSdkEntryBlocksPatch(blocks: unknown): EntrySlotResult<SdkEntryBlocksPatch, SdkEntryBlocksPatchParseError>;
+export type ContentVersionOwner = Readonly<{
+    kind: 'block';
+    blockId: EntrySlotBlockId;
+}> | Readonly<{
+    kind: 'entry';
+    contentEntryId: EntrySlotContentEntryId;
+}> | Readonly<{
+    kind: 'page';
+    pageId: EntrySlotPageId;
+}> | Readonly<{
+    kind: 'entry-slot';
+    entrySlotId: EntryBlockSlotId;
+}>;
+export type EditableBlockOwner = Readonly<{
+    kind: 'page';
+    pageId: EntrySlotPageId;
+}> | Readonly<{
+    kind: 'entry-slot';
+    entrySlotId: EntryBlockSlotId;
+}>;
+export type EntryLifecycleRecoveryCheckpoint = 'entry-fields' | 'route-metadata' | 'slot-composition' | 'block-published-refs' | 'cache-revalidation';
+export type EntryLifecycleCommitPlan = Readonly<{
+    kind: 'transactional-commit';
+}> | Readonly<{
+    kind: 'sequential-commit-with-recovery';
+    checkpoints: readonly EntryLifecycleRecoveryCheckpoint[];
+}>;
+export type EntrySlotTemplateLifecycleDecision = Readonly<{
+    publicTemplateDefinitions: 'effective-current';
+    previewTemplateDefinitions: 'draft-current';
+    removedSlotData: 'retained-hidden-until-slot-reintroduced';
+}>;
+export declare const ENTRY_SLOT_TEMPLATE_LIFECYCLE_DECISION: EntrySlotTemplateLifecycleDecision;
+export {};

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

@@ -19,3 +19,4 @@ export * from './templates/bindingValidation';
 export * from './templates/manifestAdapter';
 export * from './templates/auditBindings';
 export * from './templates/editorState';
+export * from './entry-slots';

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

@@ -126,6 +126,13 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
             readonly blockKind: "block.body-text";
             readonly scope: "entry";
             readonly bindings: import("./types").TemplateBindingRecord;
+        }, {
+            readonly blockKind: "system.entry-slot";
+            readonly scope: "template";
+            readonly content: {
+                readonly slotKey: "main";
+                readonly label: "Page content";
+            };
         }, {
             readonly blockKind: "block.event-registration";
             readonly scope: "entry";
@@ -251,7 +258,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/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[];