@riverbankcms/sdk 0.77.1 → 0.78.0

package/dist/_dts/blocks/src/system/runtime/nodes/shop-checkout-form.d.ts

@@ -0,0 +1,76 @@
+import { type Brand, type Result } from '../../../../../core/src/index';
+import type { DiscountsAvailableRequest, DiscountsAvailableResponse, ShopCheckoutRequest, UnifiedCheckoutItem, UnifiedCheckoutRequest } from '../api/types';
+import type { CommerceCheckoutState } from './shop-commerce.shared';
+export type ManualDiscountCode = Brand<string, 'ManualDiscountCode'>;
+export type CheckoutContactForm = Readonly<{
+    name: string;
+    email: string;
+}>;
+export type CheckoutDiscountForm = Readonly<{
+    discountCode: string;
+}>;
+export type ShopCheckoutForm = CheckoutContactForm & CheckoutDiscountForm;
+export type NormalizedCheckoutContact = Readonly<{
+    name: string;
+    email: string;
+}>;
+export type CheckoutFormError = Readonly<{
+    type: 'missing_contact';
+    message: string;
+}> | Readonly<{
+    type: 'invalid_email';
+    message: string;
+}> | Readonly<{
+    type: 'empty_cart';
+    message: string;
+}> | Readonly<{
+    type: 'blocked_cart';
+    reason: 'mixed_currency';
+    message: string;
+}>;
+export type CartDiscountAvailabilityRequest = Readonly<{
+    context: DiscountsAvailableRequest['context'];
+    subtotalCents: number;
+    currency: string;
+}>;
+export type CartDiscountUiState = Readonly<{
+    type: 'unavailable';
+}> | Readonly<{
+    type: 'loading';
+}> | Readonly<{
+    type: 'manual-allowed';
+}> | Readonly<{
+    type: 'auto-only';
+    autoAppliedDiscount: DiscountsAvailableResponse['autoAppliedDiscount'];
+}> | Readonly<{
+    type: 'error-unavailable';
+}>;
+export declare function normalizeManualDiscountCode(raw: string): ManualDiscountCode | null;
+export declare function normalizeCheckoutEmail(raw: string): Result<string, CheckoutFormError>;
+export declare function normalizeCheckoutContactForm(form: CheckoutContactForm): Result<NormalizedCheckoutContact, CheckoutFormError>;
+export type DirectShopCheckoutCommand = Omit<ShopCheckoutRequest, 'siteId' | 'discountCode'> & Readonly<{
+    discountCode?: ManualDiscountCode;
+}>;
+export declare function planDirectShopCheckoutRequest(input: Readonly<{
+    productType: DirectShopCheckoutCommand['productType'];
+    productId: string;
+    form: ShopCheckoutForm;
+    successUrl: string;
+    cancelUrl: string;
+    confirmDuplicate?: boolean;
+}>): Result<DirectShopCheckoutCommand, CheckoutFormError>;
+export type UnifiedCheckoutCommand = Omit<UnifiedCheckoutRequest, 'siteId' | 'discountCode'> & Readonly<{
+    discountCode?: ManualDiscountCode;
+}>;
+export declare function buildUnifiedCheckoutItems(checkout: Extract<CommerceCheckoutState, {
+    kind: 'ready';
+}>): UnifiedCheckoutItem[];
+export declare function planUnifiedCheckoutRequest(input: Readonly<{
+    checkout: CommerceCheckoutState;
+    form: ShopCheckoutForm;
+    successUrl: string;
+    cancelUrl: string;
+}>): Result<UnifiedCheckoutCommand, CheckoutFormError>;
+export declare function planCartDiscountAvailabilityRequests(checkout: CommerceCheckoutState): Result<CartDiscountAvailabilityRequest[], CheckoutFormError>;
+export declare function aggregateCartDiscountUiState(availability: readonly DiscountsAvailableResponse[]): CartDiscountUiState;
+export declare function checkoutFormForDiscountUiState(form: ShopCheckoutForm, discountUiState: CartDiscountUiState): ShopCheckoutForm;

package/dist/_dts/blocks/src/system/runtime/nodes/shop-checkout.state.d.ts

@@ -1,9 +1,6 @@
 import { type FeedbackState } from '@riverbankcms/frontend-state';
+import type { ShopCheckoutForm } from './shop-checkout-form';
 export type ShopCheckoutNotice = 'success' | 'cancelled' | null;
-export type ShopCheckoutForm = Readonly<{
-    name: string;
-    email: string;
-}>;
 export type ShopCheckoutState = Readonly<{
     form: ShopCheckoutForm;
     submission: 'idle' | 'submitting';

package/dist/_dts/blocks/src/system/runtime/nodes/shop-commerce-store.d.ts

@@ -9,6 +9,7 @@ declare class CommerceCartStore {
     addProduct(input: Readonly<{
         key: string;
         productId: string;
+        productCategoryId?: string | null;
         variantId?: string | null;
         title: string;
         variantTitle?: string | null;
@@ -36,6 +37,7 @@ export declare function useCommerceCart(siteId: string | undefined): {
     addProduct: (input: Readonly<{
         key: string;
         productId: string;
+        productCategoryId?: string | null;
         variantId?: string | null;
         title: string;
         variantTitle?: string | null;

package/dist/_dts/blocks/src/system/runtime/nodes/shop-commerce.shared.d.ts

@@ -3,6 +3,7 @@ export type CommerceCartItem = Readonly<{
     key: string;
     kind: 'product';
     productId: string;
+    productCategoryId: string | null;
     variantId?: string;
     title: string;
     variantTitle?: string | null;

package/dist/_dts/blocks/src/system/runtime/nodes/shop-discount-apply.state.d.ts

@@ -0,0 +1,52 @@
+import type { DiscountApplyRejectedReason, DiscountApplyResponse } from '../api/types';
+import { type ManualDiscountCode } from './shop-checkout-form';
+export type DiscountApplyClientRejectedReason = 'empty_code' | 'email_required';
+export type DiscountApplyRejectedReasonWithClient = DiscountApplyClientRejectedReason | DiscountApplyRejectedReason;
+export type AppliedDiscountCode = Extract<DiscountApplyResponse, {
+    type: 'applied';
+}>;
+export type DiscountApplyStatus = Readonly<{
+    type: 'idle';
+}> | Readonly<{
+    type: 'applying';
+}> | Readonly<{
+    type: 'applied';
+    discount: AppliedDiscountCode;
+}> | Readonly<{
+    type: 'rejected';
+    reason: DiscountApplyRejectedReasonWithClient;
+    message: string;
+}>;
+export type DiscountApplyState = Readonly<{
+    isOpen: boolean;
+    draftCode: string;
+    status: DiscountApplyStatus;
+}>;
+export type DiscountApplyFeedback = Readonly<{
+    tone: 'success' | 'error' | 'info';
+    message: string;
+}>;
+export type DiscountApplyAction = Readonly<{
+    type: 'open';
+}> | Readonly<{
+    type: 'draftChanged';
+    draftCode: string;
+}> | Readonly<{
+    type: 'remove';
+}> | Readonly<{
+    type: 'applyStarted';
+}> | Readonly<{
+    type: 'applySucceeded';
+    discount: AppliedDiscountCode;
+}> | Readonly<{
+    type: 'applyRejected';
+    reason: DiscountApplyRejectedReasonWithClient;
+    message: string;
+}> | Readonly<{
+    type: 'resetApplied';
+}>;
+export declare const initialDiscountApplyState: DiscountApplyState;
+export declare function discountApplyReducer(state: DiscountApplyState, action: DiscountApplyAction): DiscountApplyState;
+export declare function getAppliedDiscountCode(state: DiscountApplyState): ManualDiscountCode | null;
+export declare function isDiscountApplyInFlight(state: DiscountApplyState): boolean;
+export declare function getDiscountApplyFeedback(status: DiscountApplyStatus, formatPrice: (cents: number, currency: string) => string): DiscountApplyFeedback | null;

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

@@ -1,14 +1,12 @@
 import type { PublicMembershipProduct, PublicPassProduct } from '../../blocks/shop';
 import type { ShopDuplicateMembershipWarning as DuplicateMembershipWarning } from '../api';
+import type { ShopCheckoutForm } from './shop-checkout-form';
 export type CheckoutReturnNotice = Readonly<{
     kind: 'success';
 }> | Readonly<{
     kind: 'cancelled';
 }> | null;
-export type CheckoutForm = Readonly<{
-    email: string;
-    name: string;
-}>;
+export type CheckoutForm = ShopCheckoutForm;
 export type CheckoutItem = Readonly<{
     productType: 'pass';
     product: PublicPassProduct;

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

@@ -0,0 +1,21 @@
+import type { BlockApiClient, DiscountApplyLine } from '../api';
+import type { DiscountApplyAction, DiscountApplyState } from './shop-discount-apply.state';
+export type DiscountApplyLinesPlan = Readonly<{
+    ok: true;
+    lines: DiscountApplyLine[];
+}> | Readonly<{
+    ok: false;
+}>;
+export declare const DISCOUNT_APPLY_MESSAGES: {
+    readonly emptyCode: "Enter a discount code first.";
+    readonly emailRequired: "Enter your email before applying a code.";
+    readonly unavailable: "That code doesn't work for this checkout.";
+    readonly unknown: "We couldn't check that code. Try again.";
+};
+export declare function useDiscountApply(options: Readonly<{
+    api: BlockApiClient;
+    state: DiscountApplyState;
+    dispatch: (action: DiscountApplyAction) => void;
+    getCustomerEmail: () => string;
+    getLines: () => DiscountApplyLinesPlan;
+}>): () => Promise<void>;

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

@@ -0,0 +1,54 @@
+import type React from 'react';
+type BlockDiscountCodeSurface = 'course-registration' | 'event-registration';
+export type DiscountCodeDisclosureSurface = BlockDiscountCodeSurface | 'theme-form';
+export declare const BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES: {
+    readonly 'course-registration': {
+        readonly root: "cr-discount";
+        readonly toggle: "cr-discount__toggle";
+        readonly form: "cr-discount__form";
+        readonly label: "cr-discount__label";
+        readonly row: "cr-discount__row";
+        readonly input: "cr-discount__input";
+        readonly apply: "cr-discount__apply";
+        readonly remove: "cr-discount__remove";
+        readonly hint: "cr-discount__hint";
+        readonly feedback: "cr-discount__feedback";
+    };
+    readonly 'event-registration': {
+        readonly root: "er-discount";
+        readonly toggle: "er-discount__toggle";
+        readonly form: "er-discount__form";
+        readonly label: "er-discount__label";
+        readonly row: "er-discount__row";
+        readonly input: "er-discount__input";
+        readonly apply: "er-discount__apply";
+        readonly remove: "er-discount__remove";
+        readonly hint: "er-discount__hint";
+        readonly feedback: "er-discount__feedback";
+    };
+};
+export type DiscountCodeDisclosureProps = Readonly<{
+    surface: DiscountCodeDisclosureSurface;
+    isOpen: boolean;
+    code: string;
+    onOpen: () => void;
+    onChange: (next: string) => void;
+    onRemove: () => void;
+    onApply?: () => void;
+    id?: string;
+    toggleLabel?: string;
+    label?: string;
+    placeholder?: string;
+    applyLabel?: string;
+    removeLabel?: string;
+    hint?: string;
+    feedback?: Readonly<{
+        tone: 'success' | 'error' | 'info';
+        message: string;
+    }> | null;
+    isApplying?: boolean;
+    applyDisabled?: boolean;
+    disabled?: boolean;
+}>;
+export declare function DiscountCodeDisclosure({ surface, isOpen, code, onOpen, onChange, onRemove, onApply, id, toggleLabel, label, placeholder, applyLabel, removeLabel, hint, feedback, isApplying, applyDisabled, disabled, }: DiscountCodeDisclosureProps): React.JSX.Element;
+export {};

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

@@ -4,6 +4,8 @@
 export { CheckIcon } from './CheckIcon';
 export { ClockIcon } from './ClockIcon';
 export { CrossIcon } from './CrossIcon';
+export { BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES, DiscountCodeDisclosure, } from './DiscountCodeDisclosure';
+export type { DiscountCodeDisclosureProps, DiscountCodeDisclosureSurface, } from './DiscountCodeDisclosure';
 export { ActionRow } from './ActionRow';
 export type { ActionRowProps } from './ActionRow';
 export { BookingOptionCompactRow } from './BookingOptionCompactRow';

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

@@ -8,5 +8,5 @@ export { DEFAULT_CURRENCY } from './types';
 export { BOOK_TARGET_PARAMS, buildCheckoutReturnUrls, resolveDedicatedBookingHref, resolveDedicatedBookingPath, resolveDedicatedBookingTarget, formatPrice, scrollToBlock, consumeSearchParam, consumeSearchParams, validateFormData, getStepNumber, } from './utils';
 export type { DedicatedBookingTarget, UniversalBookingRouteTarget, } from './utils';
 export { createBodyThemePortalRoot } from './utils';
-export { ActionRow, BookingOptionCompactRow, BookingOptionList, CheckIcon, ClockIcon, CrossIcon, FieldValidationMessage, FeedbackMessage, getFieldValidationControlProps, MembershipHero, ModalShell, StateIcon, StepIndicator, TerminalPanel, } from './components';
-export type { ActionRowProps, BookingOptionCompactRowAction, BookingOptionCompactRowProps, BookingOptionCompactRowViewModel, BookingOptionGroupViewModel, BookingOptionListProps, BookingOptionMetaItem, FieldValidationControlInput, FieldValidationControlProps, FieldValidationMessageProps, FeedbackLiveMode, FeedbackMessageProps, FeedbackTone, ModalShellProps, StepIndicatorBaseProps, StepIndicatorProps, TerminalPanelProps, TerminalPanelTitleElement, } from './components';
+export { ActionRow, BookingOptionCompactRow, BookingOptionList, CheckIcon, ClockIcon, CrossIcon, BLOCK_DISCOUNT_CODE_DISCLOSURE_CLASSES, DiscountCodeDisclosure, FieldValidationMessage, FeedbackMessage, getFieldValidationControlProps, MembershipHero, ModalShell, StateIcon, StepIndicator, TerminalPanel, } from './components';
+export type { ActionRowProps, BookingOptionCompactRowAction, BookingOptionCompactRowProps, BookingOptionCompactRowViewModel, BookingOptionGroupViewModel, BookingOptionListProps, BookingOptionMetaItem, DiscountCodeDisclosureProps, DiscountCodeDisclosureSurface, FieldValidationControlInput, FieldValidationControlProps, FieldValidationMessageProps, FeedbackLiveMode, FeedbackMessageProps, FeedbackTone, ModalShellProps, StepIndicatorBaseProps, StepIndicatorProps, TerminalPanelProps, TerminalPanelTitleElement, } from './components';

package/dist/_dts/blocks/src/system/transforms/registry/ui.d.ts

@@ -45,8 +45,8 @@ declare const twoColumnContainerClassOptionsSchema: z.ZodObject<{
 export declare const twoColumnContainerClassTransform: TransformDefinition<z.infer<typeof twoColumnContainerClassOptionsSchema>>;
 declare const twoColumnFlexBasisOptionsSchema: z.ZodObject<{
     side: z.ZodEnum<{
-        image: "image";
         text: "text";
+        image: "image";
     }>;
 }, z.core.$strip>;
 export declare const twoColumnFlexBasisTransform: TransformDefinition<z.infer<typeof twoColumnFlexBasisOptionsSchema>>;

package/dist/_dts/blocks/src/system/transforms/typed.d.ts

@@ -73,7 +73,7 @@ export declare const transformDefinitions: {
         reverseClass: string;
     }>;
     readonly "ui.twoColumnFlexBasis": TransformDefinition<{
-        side: "image" | "text";
+        side: "text" | "image";
     }>;
     readonly "media.fromUrl": TransformDefinition<{
         width?: number;

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

@@ -0,0 +1,26 @@
+export type ContentTypeEditorContentState = Readonly<{
+    deleteDialogOpen: boolean;
+    deletePending: boolean;
+    seoDisclosure: Readonly<{
+        open: boolean;
+        lastIssueCount: number;
+    }>;
+}>;
+export type ContentTypeEditorContentAction = Readonly<{
+    type: 'delete-dialog-opened';
+}> | Readonly<{
+    type: 'delete-dialog-closed';
+}> | Readonly<{
+    type: 'delete-started';
+}> | Readonly<{
+    type: 'delete-finished';
+}> | Readonly<{
+    type: 'seo-open-changed';
+    open: boolean;
+}> | Readonly<{
+    type: 'seo-validation-state-changed';
+    issueCount: number;
+    hasMetadataError: boolean;
+}>;
+export declare function createInitialContentTypeEditorContentState(): ContentTypeEditorContentState;
+export declare function contentTypeEditorContentReducer(state: ContentTypeEditorContentState, action: ContentTypeEditorContentAction): ContentTypeEditorContentState;

package/dist/_dts/content-editor/src/definitions/factory.d.ts

@@ -0,0 +1,75 @@
+import type { ContentEntryDetail, ContentTypeKey } from '../../../api/src/content-editor';
+import type { ContentEntryDefinition, ContentEntrySnapshot, ContentLifecycleStatus, ContentTypeSchema, RoutingHelpers } from '../../../content-model/src/index';
+export type SnapshotDefaults = {
+    title: string;
+    slug?: string | null;
+};
+export type ContentEntryDefinitionPlan<TResponse, TSnapshot extends ContentEntrySnapshot> = Readonly<{
+    type: ContentTypeKey;
+    title: string;
+    kind: 'content' | 'page';
+    routing: RoutingHelpers;
+    hasRoute: boolean;
+    snapshotFromResponse: (response: TResponse) => TSnapshot;
+    getRouteId?: (response: TResponse) => string | undefined;
+}>;
+type BaseFactoryOptions<TResponse> = {
+    typeKey: ContentTypeKey;
+    schema: ContentTypeSchema;
+    entityLabel: string;
+    getRouteId?: (response: TResponse) => string | undefined;
+};
+export type ContentEntriesDefinitionPlanOptions<TContent> = BaseFactoryOptions<ContentEntryDetail<TContent>>;
+export type PagesDefinitionPlanOptions = BaseFactoryOptions<PageRecordLike>;
+type PageRecordLike = {
+    id: string;
+    draftTitle?: string | null;
+    draftPath?: string | null;
+    draftStatus?: string | null;
+    title?: string | null;
+    path?: string | null;
+    status?: string | null;
+    publishedAt?: string | null;
+    scheduledPublishAt?: string | null;
+    scheduledPublishFailedAt?: string | null;
+    scheduledPublishLastError?: string | null;
+    draftMetaTitle?: string | null;
+    draftMetaDescription?: string | null;
+    publishedMetaTitle?: string | null;
+    publishedMetaDescription?: string | null;
+    ogImageId?: string | null;
+};
+type ContentEntryLikeForSnapshot = {
+    entry: {
+        id: string;
+    };
+    route: {
+        draftTitle?: string | null;
+        draftPath?: string | null;
+        draftSlug?: string | null;
+        draftStatus?: string | null;
+        publishedTitle?: string | null;
+        publishedPath?: string | null;
+        publishedSlug?: string | null;
+        status?: string | null;
+        publishedAt?: string | null;
+        scheduledPublishAt?: string | null;
+        draftMetaTitle?: string | null;
+        draftMetaDescription?: string | null;
+        publishedMetaTitle?: string | null;
+        publishedMetaDescription?: string | null;
+        ogImageId?: string | null;
+    } | null;
+    draftContent?: Record<string, unknown> | null;
+    publishedContent?: Record<string, unknown> | null;
+};
+export declare function getDefaultEntityLabel(name?: string | null): string;
+export declare function createSnapshotDefaults(entityLabel: string, slugSeed?: string | null): SnapshotDefaults;
+export declare function asContentEntrySnapshotSource<TContent>(detail: ContentEntryDetail<TContent>): ContentEntryLikeForSnapshot;
+export declare function createContentEntriesDefinitionPlan<TContent>(options: ContentEntriesDefinitionPlanOptions<TContent>): ContentEntryDefinitionPlan<ContentEntryDetail<TContent>, ContentEntrySnapshot<ContentLifecycleStatus>>;
+export declare function createPagesDefinitionPlan(options: PagesDefinitionPlanOptions): ContentEntryDefinitionPlan<PageRecordLike, ContentEntrySnapshot<'draft' | 'scheduled' | 'published'>>;
+export type PageEntrySnapshot = ContentEntrySnapshot<'draft' | 'scheduled' | 'published'>;
+export declare function createPageSnapshot(record: PageRecordLike, schema: ContentTypeSchema): PageEntrySnapshot;
+export declare function mapPageRecordToSnapshot(record: PageRecordLike, schema: ContentTypeSchema): PageEntrySnapshot;
+export type DefinitionServices<TEntry extends ContentEntrySnapshot, TMetadataPayload extends Record<string, unknown>, TPublishPayload, TMetadataResponse extends Record<string, unknown> = Record<string, unknown>> = ContentEntryDefinition<TEntry, Record<string, unknown>, TMetadataPayload, TPublishPayload, TMetadataResponse>['services'];
+export {};

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

@@ -0,0 +1,2 @@
+import type { RiverbankSiteConfig, SdkWorkflowConfig } from '../../api/src/sdkContracts';
+export declare function listManualEntryWorkflows(sdkConfig: RiverbankSiteConfig | null | undefined, contentType: string): SdkWorkflowConfig[];

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

@@ -0,0 +1,76 @@
+type FooterBlocksFooterMode = 'default' | 'blocks' | 'default+blocks' | 'none';
+export type FooterBlocksEditorBlock = Readonly<{
+    id: string;
+    kind: string;
+    kindLabel: string;
+    purpose: 'footer';
+    content: Record<string, unknown>;
+    editable: boolean;
+    readOnlyReason?: string | null;
+}>;
+export type FooterBlocksEditorLoadResponse = Readonly<{
+    blocks: FooterBlocksEditorBlock[];
+    footerMode: FooterBlocksFooterMode;
+}>;
+type FooterBlocksResponse = FooterBlocksEditorLoadResponse;
+type FooterBlock = FooterBlocksEditorBlock;
+type UpdatePayload = Readonly<{
+    blocks: Array<Readonly<{
+        id: string;
+        content: Record<string, unknown>;
+    }>>;
+    removedBlockIds?: string[];
+}>;
+export type FooterBlocksEditorReadyState = Readonly<{
+    tag: 'ready';
+    footerMode: FooterBlocksResponse['footerMode'];
+    blocks: FooterBlock[];
+    initialOrder: string[];
+    removedBlockIds: ReadonlySet<string>;
+    validationMessage: string | null;
+    previewExpanded: boolean;
+}>;
+export type FooterBlocksEditorState = Readonly<{
+    tag: 'loading';
+}> | Readonly<{
+    tag: 'error';
+    message: string;
+}> | FooterBlocksEditorReadyState;
+export type FooterBlocksEditorAction = Readonly<{
+    type: 'load-started';
+}> | Readonly<{
+    type: 'load-succeeded';
+    response: FooterBlocksResponse;
+}> | Readonly<{
+    type: 'load-failed';
+    message: string;
+}> | Readonly<{
+    type: 'block-moved';
+    blockId: string;
+    direction: -1 | 1;
+}> | Readonly<{
+    type: 'block-removed';
+    blockId: string;
+}> | Readonly<{
+    type: 'preview-toggled';
+    expanded: boolean;
+}> | Readonly<{
+    type: 'validation-message-set';
+    message: string | null;
+}>;
+export type FooterBlocksPreviewState = Readonly<{
+    blocks: Array<Readonly<{
+        id: string;
+        content: Record<string, unknown>;
+        kind: string;
+        kindLabel: string;
+        readOnlyReason: string | null;
+    }>>;
+    removedBlockIds: string[];
+}>;
+export declare function createInitialFooterBlocksEditorState(): FooterBlocksEditorState;
+export declare function footerBlocksEditorReducer(state: FooterBlocksEditorState, action: FooterBlocksEditorAction): FooterBlocksEditorState;
+export declare function selectFooterBlocksStructuralChanges(state: FooterBlocksEditorState): boolean;
+export declare function buildFooterBlocksUpdatePayload(state: FooterBlocksEditorReadyState, getDraftContent: (block: FooterBlock) => Record<string, unknown> | null): UpdatePayload;
+export declare function selectFooterBlocksPreview(state: FooterBlocksEditorReadyState, getDraftContent: (block: FooterBlock) => Record<string, unknown> | null): FooterBlocksPreviewState | null;
+export {};

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

@@ -23,6 +23,11 @@ export { useStoreBinding, parseEditorPath } from './primitives/shared';
 export type { PathInfo } from './primitives/shared';
 export * from './ai/overlayHelpers';
 export { diffPaths, isUnpublishedChangesDebugEnabled } from './debug/unpublishedChangesDebug';
+export { listManualEntryWorkflows } from './entryWorkflows';
+export { pageWorkflowDraftContent, pageWorkflowPublishedContent, type PageWorkflowDraftSource, type PageWorkflowPublishedSource, } from './pageWorkflowContent';
+export { contentTypeEditorContentReducer, createInitialContentTypeEditorContentState, type ContentTypeEditorContentAction, type ContentTypeEditorContentState, } from './contentTypeEditorContentState';
+export { buildFooterBlocksUpdatePayload, createInitialFooterBlocksEditorState, footerBlocksEditorReducer, selectFooterBlocksPreview, selectFooterBlocksStructuralChanges, type FooterBlocksEditorBlock, type FooterBlocksEditorAction, type FooterBlocksEditorLoadResponse, type FooterBlocksEditorReadyState, type FooterBlocksEditorState, type FooterBlocksPreviewState, } from './footerBlocksEditorState';
+export { asContentEntrySnapshotSource, createContentEntriesDefinitionPlan, createPageSnapshot, createPagesDefinitionPlan, createSnapshotDefaults, getDefaultEntityLabel, mapPageRecordToSnapshot, type ContentEntriesDefinitionPlanOptions, type ContentEntryDefinitionPlan, type DefinitionServices, type PageEntrySnapshot, type PagesDefinitionPlanOptions, type SnapshotDefaults, } from './definitions/factory';
 export { canRedoHistory, canUndoHistory, createHistoryState, asEditorBlockId, pushHistoryEntry, redoHistory, replaceHistoryPresent, undoHistory, type HistoryState, type EditorBlockId, } from './ui/editorHistory';
 export { classifyHistoryShortcut, isNativeHistoryTarget, type HistoryShortcutCommand } from './historyShortcuts';
 export type { ContentEntryControllerOptions, ContentEntryControllerState, DraftWorkflowStatus, MetadataAutosaveConfig, MetadataKindConfig, } from './types';

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

@@ -0,0 +1,29 @@
+import type { WorkflowPageDraftContent, WorkflowPagePublishedContent } from '../../api/src/content-editor';
+type PageRouteCanonicalUrl = Readonly<{
+    canonicalUrl?: string | null;
+}>;
+export type PageWorkflowDraftSource = Readonly<{
+    draftTitle?: string | null;
+    draftSlug?: string | null;
+    draftStatus?: string | null;
+    scheduledPublishAt?: string | null;
+    draftMetaTitle?: string | null;
+    draftMetaDescription?: string | null;
+    canonicalUrl?: string | null;
+    ogImageId?: string | null;
+    route?: PageRouteCanonicalUrl | null;
+}>;
+export type PageWorkflowPublishedSource = Readonly<{
+    title?: string | null;
+    slug?: string | null;
+    status?: string | null;
+    publishedAt?: string | null;
+    publishedMetaTitle?: string | null;
+    publishedMetaDescription?: string | null;
+    canonicalUrl?: string | null;
+    ogImageId?: string | null;
+    route?: PageRouteCanonicalUrl | null;
+}>;
+export declare function pageWorkflowDraftContent(page: PageWorkflowDraftSource): WorkflowPageDraftContent;
+export declare function pageWorkflowPublishedContent(page: PageWorkflowPublishedSource): WorkflowPagePublishedContent | null;
+export {};

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

@@ -8,13 +8,13 @@ declare const BaseContentFieldSchema: z.ZodObject<{
         number: "number";
         boolean: "boolean";
         date: "date";
+        text: "text";
+        textarea: "textarea";
+        select: "select";
         url: "url";
         media: "media";
         button: "button";
         link: "link";
-        select: "select";
-        textarea: "textarea";
-        text: "text";
         richText: "richText";
         file: "file";
         datetime: "datetime";

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

@@ -18,3 +18,4 @@ export * from './templates/fieldPaths';
 export * from './templates/bindingValidation';
 export * from './templates/manifestAdapter';
 export * from './templates/auditBindings';
+export * from './templates/editorState';

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

@@ -40,4 +40,8 @@ export declare function fixedPathOrNull(routeTemplate: RouteTemplate): string |
 /** Returns the first path segment, or undefined when the template has no fixed prefix segment. */
 export declare function getRouteTemplatePrefix(routeTemplate: RouteTemplate): string | undefined;
 export declare function expandSlug(routeTemplate: RouteTemplate, slug: string): string;
+export declare function buildContentEntryRoutePath(input: Readonly<{
+    routePattern: string | null;
+    slug: string;
+}>): string;
 export declare function describeRouteTemplateParseError(error: RouteTemplateParseError): string;

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

@@ -0,0 +1,25 @@
+import type { TemplateBindingValue } from './types';
+export type TemplateEditorBindingDescriptor = TemplateBindingValue | Record<string, unknown>;
+export type TemplateEditorBindings = Record<string, TemplateEditorBindingDescriptor>;
+export type TemplateEditorBlockBindings = Record<string, TemplateEditorBindings>;
+export type TemplateEditorBlockBindingSource = Readonly<{
+    id: string;
+    scope: string;
+    bindings?: Record<string, unknown> | null;
+}>;
+export type ParsedTemplateEditorBindings = Readonly<{
+    ok: true;
+    bindings: TemplateEditorBindings;
+}> | Readonly<{
+    ok: false;
+    message: string;
+}>;
+export declare function normalizeTemplateEditorBindings(bindings: Record<string, unknown> | null | undefined): TemplateEditorBindings;
+export declare function serializeTemplateEditorBindingsJson(bindings: TemplateEditorBindings): string;
+export declare function parseTemplateEditorBindingsJson(jsonValue: string): ParsedTemplateEditorBindings;
+export declare function mergeTemplateBindingEdits(currentBindings: TemplateEditorBindings, editedBindings: TemplateEditorBindings): TemplateEditorBindings;
+export declare function setTemplateEditorBinding(bindings: TemplateEditorBindings, propId: string, binding: TemplateEditorBindingDescriptor): TemplateEditorBindings;
+export declare function removeTemplateEditorBinding(bindings: TemplateEditorBindings, propId: string): TemplateEditorBindings;
+export declare function createEntryTemplateBindingRecords(blocks: readonly TemplateEditorBlockBindingSource[]): TemplateEditorBlockBindings;
+export declare function setTemplateBlockBinding(allBindings: TemplateEditorBlockBindings, blockId: string, propId: string, binding: TemplateEditorBindingDescriptor): TemplateEditorBlockBindings;
+export declare function removeTemplateBlockBinding(allBindings: TemplateEditorBlockBindings, blockId: string, propId: string): TemplateEditorBlockBindings;

package/dist/_dts/core/src/csv-cells.d.ts

@@ -0,0 +1,10 @@
+import type { CsvCell } from './csv-types';
+export declare const csvEmptyCell: () => CsvCell;
+export declare const csvTextCell: (value: string | null | undefined) => CsvCell;
+export declare const csvIntegerCell: (value: number | null | undefined) => CsvCell;
+export declare const csvDecimalCell: (value: number | null | undefined, decimals: number) => CsvCell;
+export declare const csvMoneyCentsCell: (cents: number | null | undefined, currency: string | null | undefined) => CsvCell;
+export declare const csvIsoDateCell: (value: string | null | undefined) => CsvCell;
+export declare const csvIsoDateTimeCell: (value: string | null | undefined) => CsvCell;
+export declare const csvBooleanCell: (value: boolean | null | undefined) => CsvCell;
+export declare function formatCsvCell(cell: CsvCell): string;

package/dist/_dts/core/src/csv-date-filter.d.ts

@@ -0,0 +1,27 @@
+import type { CsvExportDatePolicy, CsvExportId, ExportDateBasis, ExportDateFilterError, ExportDateRange, ResolvedExportDateWindow } from './csv-types';
+export type ResolveExportDateWindowInput = Readonly<{
+    exportId: CsvExportId;
+    policy: CsvExportDatePolicy;
+    range: ExportDateRange;
+    requestedBasis?: ExportDateBasis;
+    timeZone: string;
+    today?: Date;
+}>;
+export type ResolveExportDateWindowInputFor<Basis extends ExportDateBasis> = Readonly<{
+    exportId: CsvExportId;
+    policy: CsvExportDatePolicy<Basis>;
+    range: ExportDateRange;
+    requestedBasis?: Basis;
+    timeZone: string;
+    today?: Date;
+}>;
+export type ResolveExportDateWindowResult<Basis extends ExportDateBasis = ExportDateBasis> = Readonly<{
+    ok: true;
+    window: ResolvedExportDateWindow<Basis>;
+}> | Readonly<{
+    ok: false;
+    error: ExportDateFilterError;
+}>;
+export declare function resolveExportDateWindow<Basis extends ExportDateBasis>(input: ResolveExportDateWindowInputFor<Basis>): ResolveExportDateWindowResult<Basis>;
+export declare function resolveExportDateWindow(input: ResolveExportDateWindowInput): ResolveExportDateWindowResult;
+export declare function describeExportDateBasis(basis: ExportDateBasis): string;

package/dist/_dts/core/src/csv-escape.d.ts

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