@riverbankcms/sdk 0.64.0 → 0.68.0

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

@@ -84,6 +84,7 @@ export declare const transformDefinitions: {
     readonly "content.interpolateRichTextTokens": TransformDefinition<{
         tokens: ("year" | "site_name")[];
     }>;
+    readonly "value.csv": TransformDefinition;
     readonly "boxStyles.semanticGap": TransformDefinition<{
         fallback?: import("../spacing").SemanticSpacing;
     }>;
@@ -110,7 +111,7 @@ export declare function bindProp(from: string, opts?: {
     readonly $bind: {
         readonly pick?: "value" | "context" | "collection" | undefined;
         readonly fallback?: {} | null | undefined;
-        readonly transforms?: TransformStep<"string.uppercase" | "value.fallback" | "date.formatShort" | "layout.maxWidthClass" | "layout.headerRootClass" | "layout.footerRootClass" | "layout.headerRootStyle" | "layout.footerRootStyle" | "ui.headerNavLinkClass" | "ui.headingClassFromAlignment" | "ui.bodyClassFromAlignment" | "ui.stackAlignFromAlignment" | "ui.sectionStateTone" | "ui.heroContentWrapperClass" | "ui.heroCtaJustify" | "ui.heroStackJustifyFromVerticalAlignment" | "ui.heroGridClassFromVerticalAlignment" | "ui.conditionalClass" | "ui.twoColumnContainerClass" | "ui.twoColumnFlexBasis" | "media.fromUrl" | "content.interpolateRichTextTokens" | "boxStyles.semanticGap" | "boxStyles.semanticGapValue" | "layout.footerBottomBarClass" | "layout.footerBottomBarContainerClass" | "layout.footerBottomBarStyle" | "layout.footerSplitNavSingleClass" | "layout.footerSplitMainClass" | "layout.footerLogoClass" | "layout.footerLogoMediaClass" | "layout.footerLogoTextVisible">[] | undefined;
+        readonly transforms?: TransformStep<"string.uppercase" | "value.fallback" | "date.formatShort" | "value.csv" | "layout.maxWidthClass" | "layout.headerRootClass" | "layout.footerRootClass" | "layout.headerRootStyle" | "layout.footerRootStyle" | "ui.headerNavLinkClass" | "ui.headingClassFromAlignment" | "ui.bodyClassFromAlignment" | "ui.stackAlignFromAlignment" | "ui.sectionStateTone" | "ui.heroContentWrapperClass" | "ui.heroCtaJustify" | "ui.heroStackJustifyFromVerticalAlignment" | "ui.heroGridClassFromVerticalAlignment" | "ui.conditionalClass" | "ui.twoColumnContainerClass" | "ui.twoColumnFlexBasis" | "media.fromUrl" | "content.interpolateRichTextTokens" | "boxStyles.semanticGap" | "boxStyles.semanticGapValue" | "layout.footerBottomBarClass" | "layout.footerBottomBarContainerClass" | "layout.footerBottomBarStyle" | "layout.footerSplitNavSingleClass" | "layout.footerSplitMainClass" | "layout.footerLogoClass" | "layout.footerLogoMediaClass" | "layout.footerLogoTextVisible">[] | undefined;
         readonly from: string;
     };
 };

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

@@ -5249,6 +5249,74 @@ export type Database = {
                 };
                 Relationships: [];
             };
+            demo_media_uploads: {
+                Row: {
+                    bytes: number;
+                    claim_id: string | null;
+                    created_at: string;
+                    id: string;
+                    instance_id: string;
+                    media_asset_id: string;
+                    site_id: string;
+                    source: string;
+                    updated_at: string;
+                    uploaded_by_user_id: string | null;
+                };
+                Insert: {
+                    bytes?: number;
+                    claim_id?: string | null;
+                    created_at?: string;
+                    id?: string;
+                    instance_id: string;
+                    media_asset_id: string;
+                    site_id: string;
+                    source?: string;
+                    updated_at?: string;
+                    uploaded_by_user_id?: string | null;
+                };
+                Update: {
+                    bytes?: number;
+                    claim_id?: string | null;
+                    created_at?: string;
+                    id?: string;
+                    instance_id?: string;
+                    media_asset_id?: string;
+                    site_id?: string;
+                    source?: string;
+                    updated_at?: string;
+                    uploaded_by_user_id?: string | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: "demo_media_uploads_claim_id_fkey";
+                        columns: ["claim_id"];
+                        isOneToOne: false;
+                        referencedRelation: "demo_claims";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "demo_media_uploads_instance_id_fkey";
+                        columns: ["instance_id"];
+                        isOneToOne: false;
+                        referencedRelation: "demo_instances";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "demo_media_uploads_media_asset_id_fkey";
+                        columns: ["media_asset_id"];
+                        isOneToOne: true;
+                        referencedRelation: "media_assets";
+                        referencedColumns: ["id"];
+                    },
+                    {
+                        foreignKeyName: "demo_media_uploads_site_id_fkey";
+                        columns: ["site_id"];
+                        isOneToOne: false;
+                        referencedRelation: "sites";
+                        referencedColumns: ["id"];
+                    }
+                ];
+            };
             digital_product_entitlement_grants: {
                 Row: {
                     created_at: string;
@@ -15401,6 +15469,19 @@ export type Database = {
                     ticket_type_id: string;
                 }[];
             };
+            get_form_submission_stats: {
+                Args: {
+                    p_form_ids: string[];
+                    p_recent_since: string;
+                    p_site_id: string;
+                };
+                Returns: {
+                    form_id: string;
+                    latest_submission_at: string;
+                    recent_count: number;
+                    total_count: number;
+                }[];
+            };
             get_public_event_attendee_counts: {
                 Args: {
                     instance_ids: string[];

package/dist/_dts/preview-next/src/client/blocks/pageDesignRuntimePreview.d.ts

@@ -1,5 +1,5 @@
 import type { BlockItem } from '@riverbankcms/editor-blocks';
-import type { PageDesignEditorReadModel } from '@riverbankcms/theme-core/site-styles/previewCompiler';
+import type { PageDesignEditorReadModel, SurfaceResolutionContext } from '@riverbankcms/theme-core/site-styles/previewCompiler';
 import type { PreviewPageDesignEditorState } from '../preview/PageDesignEditorStateContext';
 import { type RuntimeContentDecorationProjection } from './previewProjection';
 export type RuntimePreviewSource = Readonly<{
@@ -7,9 +7,13 @@ export type RuntimePreviewSource = Readonly<{
 }> | Readonly<{
     kind: 'apply-editor-model';
     editorModel: PageDesignEditorReadModel;
+    surfaceResolutionContext: SurfaceResolutionContext;
 }>;
 export declare function applyPageDesignRuntimeFieldsToBlockItems(blockItems: readonly BlockItem[], source: RuntimePreviewSource): BlockItem[];
 export declare function applyPageDesignRuntimeFieldsToBlockContent(block: BlockItem, content: Record<string, unknown> | null, source: RuntimePreviewSource): Record<string, unknown> | null;
-export declare function buildPageDesignRuntimeFieldsByBlockId(editorModel: PageDesignEditorReadModel): RuntimeContentDecorationProjection['fieldsByBlockId'];
+export declare function buildPageDesignRuntimeFieldsByBlockId(editorModel: PageDesignEditorReadModel, surfaceResolutionContext: SurfaceResolutionContext): RuntimeContentDecorationProjection['fieldsByBlockId'];
 export declare function pageDesignRuntimeProjectionFromSource(source: RuntimePreviewSource): RuntimeContentDecorationProjection | null;
-export declare function resolveRuntimePreviewSource(pageDesignState: PreviewPageDesignEditorState): RuntimePreviewSource;
+export declare function resolveRuntimePreviewSource(input: Readonly<{
+    pageDesignState: PreviewPageDesignEditorState;
+    surfaceResolutionContext: SurfaceResolutionContext | null;
+}>): RuntimePreviewSource;

package/dist/_dts/preview-next/src/client/blocks/previewProjection/runtimeContentDecoration.d.ts

@@ -1,5 +1,5 @@
 import type { BlockItem } from '@riverbankcms/editor-blocks';
-import { type PageDesignEditorReadModel } from '@riverbankcms/theme-core/site-styles/previewCompiler';
+import { type PageDesignEditorReadModel, type SurfaceResolutionContext } from '@riverbankcms/theme-core/site-styles/previewCompiler';
 import type { CanonicalBlockContent, PreviewRenderContent, RuntimeContentDecorationProjection } from './types';
-export declare function runtimeContentDecorationProjectionFromEditorModel(editorModel: PageDesignEditorReadModel): RuntimeContentDecorationProjection;
+export declare function runtimeContentDecorationProjectionFromEditorModel(editorModel: PageDesignEditorReadModel, surfaceResolutionContext: SurfaceResolutionContext): RuntimeContentDecorationProjection;
 export declare function applyRuntimeContentDecorationProjection(block: BlockItem, content: CanonicalBlockContent | PreviewRenderContent | null, projection: RuntimeContentDecorationProjection): PreviewRenderContent;

package/dist/_dts/sdk/src/bookings/index.d.ts

@@ -25,8 +25,11 @@
  * @packageDocumentation
  */
 import * as React from 'react';
-import type { BookingFormClientProps, UseBookingFormConfigResult } from './types';
+import { HeadlessBookingAltchaWidget, createBookingBlockApiConfig, getAppointmentBookingOverrideInput, useHeadlessBookingFlow } from '@riverbankcms/blocks/client';
+import type { BookingFormClientProps, HeadlessBookingProviderProps, UseBookingFormConfigResult } from './types';
 export declare const BookingFormClient: React.FC<BookingFormClientProps>;
 export declare function useBookingFormConfig(siteId: string, formId: string): UseBookingFormConfigResult;
+export declare const HeadlessBookingProvider: React.FC<HeadlessBookingProviderProps>;
+export { HeadlessBookingAltchaWidget, createBookingBlockApiConfig, getAppointmentBookingOverrideInput, useHeadlessBookingFlow, };
 export type { BookingService, BookingFormConfig } from './types';
-export type { Service, TimeSlot, BookingFormSettings, BookingFormSchema, BookingFormField, BookingFormData, BookingSubmissionData, BookingSubmissionResult, BookingFormClientProps, BookingFormClientForm, BookingFormClientService, UseBookingFormConfigResult, } from './types';
+export type { Service, TimeSlot, BookingFormSettings, BookingFormSchema, BookingFormField, BookingFormData, BookingSubmissionData, BookingSubmissionResult, BookingFormClientProps, BookingFormClientForm, BookingFormClientService, HeadlessBookingFlow, HeadlessBookingFlowOptions, HeadlessBookingProviderProps, AppointmentBookingOverrideData, AppointmentBookingOverrideInput, AppointmentBookingOverrideInputResult, BookingAvailabilityQuery, BookingAppointmentPackagesModel, BookingAppointmentPackagesUnavailableReason, BookingPaymentOptionViewModel, BookingPaymentSelectionViewModel, BookingFieldValue, BookingFieldView, BookingFlowActionResult, BookingFlowFeedback, BookingFlowStatus, BookingResourceView, BookingResourcesModel, BookingFlowStep, BookingFlowStepId, BookingFlowView, BookingSlotView, BookingSubmitActionResult, BookingSubmitOptions, BookingValidationErrors, DerivedBookingFlowSteps, DeriveBookingFlowStepsInput, UseBookingFormConfigResult, } from './types';

package/dist/_dts/sdk/src/bookings/types.d.ts

@@ -4,6 +4,8 @@
  * These types are exported for SDK sites to use when building custom booking UIs.
  */
 import type { BookingFlexibleBalanceConfig, BookingInstalmentPlanConfig } from '@riverbankcms/core';
+import type { AppointmentBookingOverrideData, AppointmentBookingOverrideInput, AppointmentBookingOverrideInputResult, BookingAvailabilityQuery, BookingAppointmentPackagesModel, BookingAppointmentPackagesUnavailableReason, BookingPaymentOptionViewModel, BookingPaymentSelectionViewModel, BookingFieldValue, BookingFieldView, BookingFlowActionResult, BookingFlowFeedback, BookingFlowStatus, BookingResourceView, BookingFlowStep, BookingFlowStepId, BookingFlowView, BookingResourcesModel, BookingSlotView, BookingSubmitActionResult, BookingSubmitOptions, BookingValidationErrors, DerivedBookingFlowSteps, DeriveBookingFlowStepsInput, HeadlessBookingFlow, HeadlessBookingFlowOptions, HeadlessBookingProviderProps } from '@riverbankcms/blocks/client';
+export type { AppointmentBookingOverrideData, AppointmentBookingOverrideInput, AppointmentBookingOverrideInputResult, BookingAvailabilityQuery, BookingAppointmentPackagesModel, BookingAppointmentPackagesUnavailableReason, BookingPaymentOptionViewModel, BookingPaymentSelectionViewModel, BookingFieldValue, BookingFieldView, BookingFlowActionResult, BookingFlowFeedback, BookingFlowStatus, BookingResourceView, BookingFlowStep, BookingFlowStepId, BookingFlowView, BookingResourcesModel, BookingSlotView, BookingSubmitActionResult, BookingSubmitOptions, BookingValidationErrors, DerivedBookingFlowSteps, DeriveBookingFlowStepsInput, HeadlessBookingFlow, HeadlessBookingFlowOptions, HeadlessBookingProviderProps, };
 /**
  * A bookable service (e.g., "30-minute consultation", "Hair cut")
  *

package/dist/_dts/sdk/src/cli/commands/push/execute/footer.d.ts

@@ -0,0 +1,33 @@
+import type { EnvTarget } from '../../../helpers';
+import type { OutputContext } from '../../../output';
+import { type FooterDiff } from '../../../sync/diff';
+import type { PushOptions } from '../options';
+export type FooterPushExecutionResult = Readonly<{
+    success: boolean;
+}>;
+type FooterPushDecision = Readonly<{
+    kind: 'unchanged';
+}> | Readonly<{
+    kind: 'dry-run';
+    diff: FooterDiff;
+}> | Readonly<{
+    kind: 'apply';
+    diff: FooterDiff;
+}>;
+export declare function footerPushDecision(diff: FooterDiff | null, dryRun: boolean): FooterPushDecision;
+export declare function footerDryRunPayload(diff: FooterDiff): Readonly<{
+    kind: 'push';
+    scope: 'footer';
+    dryRun: true;
+    changes: readonly string[];
+}>;
+export declare function executeFooterPush(input: Readonly<{
+    output: OutputContext;
+    target: EnvTarget;
+    options: PushOptions & {
+        dryRun: boolean;
+    };
+    jsonOutput: boolean;
+    skipMeta: boolean;
+}>): Promise<FooterPushExecutionResult>;
+export {};

package/dist/_dts/sdk/src/cli/commands/push/scopes/commandBackedDatedOfferingScope.d.ts

@@ -0,0 +1,32 @@
+import type { SiteId } from '@riverbankcms/core';
+import { type CliDatedOfferingCommandBatchSource, type CliDatedOfferingCommandCompileInput, type DatedOfferingReportSubject, type DatedOfferingUpsertItem } from '../../../site-commands';
+import type { WriterOptions } from '../../../content/writer';
+import type { PushScopeResult, ScopePushContext } from './types';
+type CommandBackedDatedOfferingScopeConfig<TLocal, TRemote> = Readonly<{
+    source: CliDatedOfferingCommandBatchSource;
+    scopeName: string;
+    itemLabelSingular: string;
+    scopeCommand: DatedOfferingReportSubject['scopeCommand'];
+    getIdentifier: (item: TLocal) => string;
+    getDisplayLabel: (item: TLocal) => string;
+    shouldPushItem?: (item: TLocal) => boolean;
+    readLocal: (contentDir: string) => Promise<TLocal[]>;
+    readMeta: (contentDir: string) => Promise<Record<string, {
+        updatedAt?: string;
+    }> | null>;
+    fetchRemote: () => Promise<TRemote[]>;
+    getRemoteUpdatedAt: (remote: TRemote) => string;
+    findRemote: (remoteItems: readonly TRemote[], identifier: string) => TRemote | undefined;
+    getRemoteIdentifier: (remote: TRemote) => string;
+    updateLocalMeta: (contentDir: string, options?: WriterOptions) => Promise<void>;
+    readOnlyStatusWarning?: (item: TLocal) => string | null;
+    buildCompileInput: (input: Readonly<{
+        source: CliDatedOfferingCommandBatchSource;
+        siteId: SiteId;
+        targetEnv: ScopePushContext['targetEnv'];
+        upserts: readonly DatedOfferingUpsertItem<TLocal>[];
+        deletes: readonly string[];
+    }>) => CliDatedOfferingCommandCompileInput;
+}>;
+export declare function pushCommandBackedDatedOfferingScope<TLocal, TRemote>(ctx: ScopePushContext, config: CommandBackedDatedOfferingScopeConfig<TLocal, TRemote>): Promise<PushScopeResult>;
+export {};

package/dist/_dts/sdk/src/cli/commands/push/scopes/types.d.ts

@@ -1,9 +1,13 @@
 import type { OutputContext } from '../../../output';
 import type { ManagementClient } from '../../../../client/management';
 import type { WriterOptions } from '../../../content/writer';
+import type { SiteId } from '@riverbankcms/core';
+import type { EnvTarget } from '../../../helpers';
 export interface ScopePushContext {
     output: OutputContext;
     contentDir: string;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
     client: ManagementClient;
     dryRun: boolean;
     force: boolean;
@@ -14,7 +18,7 @@ export interface ScopePushContext {
     skipMeta: boolean;
     humanDiff: boolean;
 }
-export type PushScopeResultStatus = 'noop' | 'dry-run' | 'aborted' | 'pushed';
+export type PushScopeResultStatus = 'noop' | 'dry-run' | 'aborted' | 'failed' | 'pushed';
 export interface PushScopeItemError {
     identifier: string;
     error: string;

package/dist/_dts/sdk/src/cli/commands/push-execute.d.ts

@@ -2,12 +2,13 @@ import { type EnvTarget } from '../helpers';
 import type { OutputContext } from '../output';
 import { type JsonDiffMode } from '../sync';
 import type { PushOptions } from './push/options';
+import { type PushScope } from './push/consts';
 export interface PushExecutionResult {
     success: boolean;
 }
 type MergeRemoteValidationInput = Readonly<{
     target: EnvTarget;
-    pushScope: string;
+    pushScope: PushScope;
     contentType?: string;
     identifier?: string;
     force: boolean;

package/dist/_dts/sdk/src/cli/env.d.ts

@@ -3,12 +3,13 @@
  *
  * Loads and validates environment variables for SDK CLI commands.
  */
+import { type SiteId } from '@riverbankcms/core';
 /**
  * SDK environment configuration
  */
 export interface SdkEnvironment {
     /** Site ID to operate on */
-    siteId: string;
+    siteId: SiteId;
     /** Dashboard URL (e.g., http://localhost:4000) */
     dashboardUrl: string;
     /** Management API key (bld_mgmt_sk_...) */

package/dist/_dts/sdk/src/cli/merge-remote/entryMergePush.d.ts

@@ -1,3 +1,4 @@
+import { type SiteId } from '@riverbankcms/core';
 import type { ManagementClient } from '../../client/management/types';
 import type { LocalEntry } from '../content/reader';
 import type { EnvTarget } from '../helpers';
@@ -10,7 +11,7 @@ export declare function planAndReportRemoteEntryMerge(input: Readonly<{
     client: Pick<ManagementClient, 'entries' | 'pull'>;
     contentDir: string;
     target: EnvTarget;
-    siteId: string;
+    siteId: SiteId;
     contentType?: string;
     identifier?: string;
     localEntries: ReadonlyMap<string, readonly LocalEntry[]>;

package/dist/_dts/sdk/src/cli/site-commands/commandKeys.d.ts

@@ -0,0 +1,13 @@
+import type { Brand } from '@riverbankcms/core';
+export type CliContentTypeKey = Brand<string, 'SdkCliContentTypeKey'>;
+export type CliEntryIdentifier = Brand<string, 'SdkCliEntryIdentifier'>;
+export type CliPageIdentifier = Brand<string, 'SdkCliPageIdentifier'>;
+export type CliBlockIdentifier = Brand<string, 'SdkCliBlockIdentifier'>;
+export type CliFormSlug = Brand<string, 'SdkCliFormSlug'>;
+export type CliNavigationMenuName = Brand<string, 'SdkCliNavigationMenuName'>;
+export declare const asCliContentTypeKey: (value: string) => CliContentTypeKey;
+export declare const asCliEntryIdentifier: (value: string) => CliEntryIdentifier;
+export declare const asCliPageIdentifier: (value: string) => CliPageIdentifier;
+export declare const asCliBlockIdentifier: (value: string) => CliBlockIdentifier;
+export declare const asCliFormSlug: (value: string) => CliFormSlug;
+export declare const asCliNavigationMenuName: (value: string) => CliNavigationMenuName;

package/dist/_dts/sdk/src/cli/site-commands/commandRuntime.d.ts

@@ -0,0 +1,144 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type DryRunReport, type SiteCommandBatch, type SiteCommandExecutionSuccess, type SiteCommandOf, type SiteCommandPlanFor, type SiteCommandRef, type SiteCommandType, type SiteCommandValidationError } from '@riverbankcms/site-commands';
+import type { EnvTarget } from '../helpers';
+export type CliCommandBatchRefInput<TSource extends string = string> = Readonly<{
+    source: TSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+}>;
+export type CliCommandExecutionError<TCommandType extends SiteCommandType> = Readonly<{
+    code: 'management_api_failed';
+    commandRef: SiteCommandRef;
+    commandType: TCommandType;
+    message: string;
+}>;
+export type CliCommandExecutionResult<TCommandType extends SiteCommandType> = Readonly<{
+    status: 'applied';
+    applied: readonly SiteCommandExecutionSuccess[];
+}> | Readonly<{
+    status: 'failed';
+    applied: readonly SiteCommandExecutionSuccess[];
+    failed: CliCommandExecutionError<TCommandType>;
+}>;
+export type PlannedCliCommand<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: SiteCommandType;
+}>> = Readonly<{
+    command: TCommand;
+}>;
+export type CliCommandReportBinding<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: SiteCommandType;
+}>, TSubject> = Readonly<{
+    command: TCommand;
+    reportSubject: TSubject;
+}>;
+export type CliCommandReportedPlannedCommand<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: SiteCommandType;
+}>, TSubject> = Readonly<{
+    plannedCommand: PlannedCliCommand<TCommand>;
+    reportSubject: TSubject;
+}>;
+export type CliCommandExecutionReportFailure<TSubject> = Readonly<{
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+}>;
+export type CliCommandOutcome<TSubject> = Readonly<{
+    status: 'applied';
+    commandRef: SiteCommandRef;
+    commandType: SiteCommandType;
+    subject: TSubject;
+}> | Readonly<{
+    status: 'failed';
+    commandRef: SiteCommandRef;
+    commandType: SiteCommandType;
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+}> | Readonly<{
+    status: 'skipped_by_stop_policy';
+    commandRef: SiteCommandRef;
+    commandType: SiteCommandType;
+    identifier: string;
+    subject: TSubject;
+}> | Readonly<{
+    status: 'compile_failed';
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+}>;
+export type CliCommandExecutionReport<TSubject> = Readonly<{
+    outcomes: readonly CliCommandOutcome<TSubject>[];
+    appliedSubjects: readonly TSubject[];
+    failure: CliCommandExecutionReportFailure<TSubject> | null;
+    warnings: readonly string[];
+}>;
+export type CliCommandValidationCompileError = Readonly<{
+    code: 'command_validation_failed';
+    errors: readonly SiteCommandValidationError[];
+    message: string;
+}>;
+export type CliCommandCompileBatchSuccess<TCommandType extends SiteCommandType> = Readonly<{
+    batch: SiteCommandBatch;
+    plan: SiteCommandPlanFor<TCommandType>;
+    dryRunReport: DryRunReport;
+}>;
+export type CliCommandCompileBatchSuccessWithReports<TCommandType extends SiteCommandType, TSubject> = Readonly<{
+    reportedCommands: readonly CliCommandReportedPlannedCommand<SiteCommandOf<TCommandType>, TSubject>[];
+}> & CliCommandCompileBatchSuccess<TCommandType>;
+export declare function createCliCommandBatchRef(input: CliCommandBatchRefInput): string;
+export declare function formatSiteCommandValidationErrors(errors: readonly {
+    message: string;
+}[]): string;
+export declare function formatManagementError(error: unknown): string;
+export declare function planCliCommandBatchForTypes<TCommandType extends SiteCommandType>(input: CliCommandBatchRefInput & Readonly<{
+    commands: readonly SiteCommandOf<TCommandType>[];
+    commandTypes: readonly TCommandType[];
+}>): Result<CliCommandCompileBatchSuccess<TCommandType>, CliCommandValidationCompileError>;
+export declare function planCliCommandBatchForBindings<TCommandType extends SiteCommandType, TSubject>(input: CliCommandBatchRefInput & Readonly<{
+    commandBindings: readonly CliCommandReportBinding<SiteCommandOf<TCommandType>, TSubject>[];
+    commandTypes: readonly TCommandType[];
+}>): Result<CliCommandCompileBatchSuccessWithReports<TCommandType, TSubject>, CliCommandValidationCompileError>;
+export declare function executeCliCommandPlan<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: TCommandType;
+}>, TCommandType extends SiteCommandType>(input: Readonly<{
+    commands: readonly PlannedCliCommand<TCommand>[];
+    applyCommand: (command: TCommand) => Promise<void>;
+}>): Promise<CliCommandExecutionResult<TCommandType>>;
+export declare function commandExecutionToReport<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: TCommandType;
+}>, TCommandType extends SiteCommandType, TSubject>(input: Readonly<{
+    execution: CliCommandExecutionResult<TCommandType>;
+    reportedCommands: readonly CliCommandReportedPlannedCommand<TCommand, TSubject>[];
+    resourceLabel: string;
+    commandDisplayIdentifier: (command: TCommand) => string;
+    includeFailureSubject?: boolean;
+}>): CliCommandExecutionReport<TSubject>;
+export declare function commandCompileFailureToReport<TSubject>(input: Readonly<{
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+    warnings?: readonly string[];
+}>): CliCommandExecutionReport<TSubject>;
+export declare function executeCompiledCliCommandPlanAsReport<TCompiledPlan extends Readonly<{
+    plan: Readonly<{
+        commands: readonly unknown[];
+    }>;
+}>, TExecutionResult, TSubject>(input: Readonly<{
+    compiledPlan: TCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+    executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
+    executionToReport: (input: Readonly<{
+        execution: TExecutionResult;
+        compiledPlan: TCompiledPlan;
+    }>) => CliCommandExecutionReport<TSubject>;
+}>): Promise<CliCommandExecutionReport<TSubject>>;
+export declare function reportFromOutcomes<TSubject>(input: Readonly<{
+    outcomes: readonly CliCommandOutcome<TSubject>[];
+    warnings?: readonly string[];
+}>): CliCommandExecutionReport<TSubject>;
+export declare function commandReportHasFailures(report: CliCommandExecutionReport<unknown>): boolean;

package/dist/_dts/sdk/src/cli/site-commands/commandRuntimeCompat.d.ts

@@ -0,0 +1,21 @@
+import { type SyncResult } from '../sync';
+import { type CliCommandExecutionReport } from './commandRuntime';
+export declare function commandReportToSyncResult<TSubject>(input: Readonly<{
+    report: CliCommandExecutionReport<TSubject>;
+    incrementSuccess: (result: SyncResult, subject: TSubject) => void;
+    recordFailure: (result: SyncResult, identifier: string, message: string, subject: TSubject | undefined) => void;
+}>): SyncResult;
+export declare function executeCompiledCliCommandPlanAsSyncResult<TCompiledPlan extends Readonly<{
+    plan: Readonly<{
+        commands: readonly unknown[];
+    }>;
+}>, TExecutionResult, TSubject>(input: Readonly<{
+    compiledPlan: TCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+    executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
+    executionToReport: (input: Readonly<{
+        execution: TExecutionResult;
+        compiledPlan: TCompiledPlan;
+    }>) => CliCommandExecutionReport<TSubject>;
+    reportToSyncResult: (report: CliCommandExecutionReport<TSubject>) => SyncResult;
+}>): Promise<SyncResult>;

package/dist/_dts/sdk/src/cli/site-commands/commandSurfaceDispatch.d.ts

@@ -0,0 +1,27 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { ContentDiff, SyncResult } from '../sync';
+import { compilePagePushCommands } from './pageCommands';
+import type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, CompiledContentPushExecutionPlan, CompiledContentPushExecutionStep, ContentPushExecutionPlan, ContentPushExecutionReport } from './pushExecutionTypes';
+export type CommandSurfaceDispatchInput = Readonly<{
+    siteId: SiteId;
+    target: EnvTarget;
+    diff: ContentDiff;
+    local: LocalContent;
+    client: ManagementClient;
+    blockFieldExtensions: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
+    onEntryCommandCount?: (commandCount: number) => void;
+    onFormCommandCount?: (commandCount: number) => void;
+    onNavigationCommandCount?: (commandCount: number) => void;
+    onPageCommandCount?: (commandCount: number) => void;
+}>;
+export type CommandSurfaceDispatchDependencies = Readonly<{
+    compileCommandSurface?: (surface: CommandSurface, input: CommandSurfaceDispatchInput) => CommandSurfaceCompileResult;
+    executeCommandSurfaceAsReport?: (surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput) => Promise<CommandSurfaceExecutionReport>;
+}>;
+export declare function compileContentPushExecutionPlan(plan: ContentPushExecutionPlan, input: CommandSurfaceDispatchInput, dependencies?: CommandSurfaceDispatchDependencies): Result<CompiledContentPushExecutionPlan, ContentPushExecutionReport>;
+export declare function executeCommandSurfaceAsReport(surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput): Promise<CommandSurfaceExecutionReport>;
+export declare function skippedRemainingCommandReports(steps: readonly CompiledContentPushExecutionStep[]): CommandSurfaceExecutionReport[];
+export declare function commandSurfaceReportToSyncResult(report: CommandSurfaceExecutionReport): SyncResult;

package/dist/_dts/sdk/src/cli/site-commands/datedOfferingCommands.d.ts

@@ -0,0 +1,56 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalCourse, LocalEvent, LocalEventCategory, LocalVenue } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { PushScopeResult } from '../commands/push/scopes/types';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandValidationCompileError } from './commandRuntime';
+export type CliDatedOfferingCommandBatchSource = 'push_venues' | 'push_event_categories' | 'push_events' | 'push_courses' | 'push_all_dated_offerings';
+export type DatedOfferingSiteCommandType = 'upsertVenue' | 'deleteVenue' | 'upsertEventCategory' | 'deleteEventCategory' | 'upsertEventSeries' | 'deleteEventSeries' | 'upsertCourse' | 'deleteCourse';
+type DatedOfferingCounter = 'created' | 'updated' | 'deleted';
+export type DatedOfferingReportSubject = Readonly<{
+    scopeCommand: 'venues' | 'event-categories' | 'events' | 'courses';
+    scopeName: string;
+    itemLabelSingular: string;
+    identifier: string;
+    counter: DatedOfferingCounter;
+}>;
+export type CliDatedOfferingCommandCompileError = Readonly<{
+    code: 'unsupported_local_shape';
+    identifier: string;
+    message: string;
+}> | CliCommandValidationCompileError;
+export type CliDatedOfferingCommandCompileInput = Readonly<{
+    source: CliDatedOfferingCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    venues?: DatedOfferingUpsertInput<LocalVenue>;
+    eventCategories?: DatedOfferingUpsertInput<LocalEventCategory>;
+    events?: DatedOfferingUpsertInput<LocalEvent>;
+    courses?: DatedOfferingUpsertInput<LocalCourse>;
+    delete?: DatedOfferingDeleteInput;
+}>;
+export type DatedOfferingUpsertInput<TItem> = Readonly<{
+    items: readonly DatedOfferingUpsertItem<TItem>[];
+}>;
+export type DatedOfferingUpsertItem<TItem> = Readonly<{
+    item: TItem;
+    exists: boolean;
+}>;
+export type DatedOfferingDeleteInput = Readonly<{
+    venues?: readonly string[];
+    eventCategories?: readonly string[];
+    events?: readonly string[];
+    courses?: readonly string[];
+}>;
+export type CliDatedOfferingCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<DatedOfferingSiteCommandType, DatedOfferingReportSubject>;
+export declare const datedOfferingSiteCommandTypes: readonly ["upsertVenue", "deleteVenue", "upsertEventCategory", "deleteEventCategory", "upsertEventSeries", "deleteEventSeries", "upsertCourse", "deleteCourse"];
+export declare function compileDatedOfferingPushCommands(input: CliDatedOfferingCommandCompileInput): Result<CliDatedOfferingCommandCompileSuccess, CliDatedOfferingCommandCompileError>;
+export declare function executeDatedOfferingCommandPlanAsPushScopeResult(input: Readonly<{
+    client: Pick<ManagementClient, 'venues' | 'eventCategories' | 'events' | 'courses'>;
+    compiledPlan: CliDatedOfferingCommandCompileSuccess;
+    scopeCommand: DatedOfferingReportSubject['scopeCommand'];
+    scopeName: string;
+}>): Promise<PushScopeResult>;
+export declare function syncResultForDatedOfferingCommandCompileError(error: CliDatedOfferingCommandCompileError, scopeCommand: DatedOfferingReportSubject['scopeCommand'], scopeName: string): PushScopeResult;
+export declare function courseSessionConflictMessage(error: unknown): string;
+export {};