@riverbankcms/sdk 0.67.0 → 0.68.0

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.headless.state.d.ts

@@ -0,0 +1,484 @@
+import type { BlockApiConfig, EligibleAppointmentPackage } from "../api/types";
+import type { TimeSlot } from "../api/types";
+import type { BookingFormConfig, BookingFormData, BookingFormField, BookingPaymentStepResolution, BookingFormServicesSource, BookingFormService, BookingSelectedCollectionOptionKind, BookingSubmissionData } from "./booking-form.state";
+export type LoadState<T> = Readonly<{
+    tag: "idle";
+}> | Readonly<{
+    tag: "loading";
+}> | Readonly<{
+    tag: "loaded";
+    value: T;
+}> | Readonly<{
+    tag: "error";
+    message: string;
+}>;
+export type BookingFlowStepId = "service-selection" | "datetime-selection" | "payment-selection" | "custom-fields";
+export type BookingFlowStepState = "complete" | "active" | "available" | "blocked" | "hidden";
+export type BookingFlowStep = Readonly<{
+    id: BookingFlowStepId;
+    label: string;
+    state: BookingFlowStepState;
+    index: number;
+    visibleIndex: number | null;
+    errors: BookingValidationErrors;
+    canEnter: boolean;
+    canLeave: boolean;
+}>;
+export type BookingValidationErrors = Readonly<{
+    formError: string | null;
+    fieldErrors: Readonly<Record<string, string>>;
+}>;
+export type BookingFieldValue = string | number | boolean | readonly string[] | null;
+export type BookingSlotView = Readonly<{
+    key: string;
+    startAt: string;
+    endAt: string;
+    resourceId: string;
+    resourceName?: string;
+    label?: string;
+}>;
+export type BookingResourceView = Readonly<{
+    id: string;
+    label: string;
+}>;
+export type BookingFlowFeedback = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "success";
+    message: string;
+    resourceName: string | null;
+}> | Readonly<{
+    kind: "error";
+    scope: "submission" | "verification" | "discount" | "altcha" | "availability" | "payment";
+    message: string;
+}> | Readonly<{
+    kind: "info";
+    scope: "verification" | "payment";
+    message: string;
+}>;
+export type AvailabilitySelectionInvalidation = Readonly<{
+    kind: "preserve";
+}> | Readonly<{
+    kind: "date_unavailable";
+    message: string;
+}> | Readonly<{
+    kind: "slot_unavailable";
+    message: string;
+}>;
+export type BookingFlowStatus = Readonly<{
+    tag: "ready";
+}> | Readonly<{
+    tag: "submitting";
+}> | Readonly<{
+    tag: "success";
+    resourceName: string | null;
+}> | Readonly<{
+    tag: "error";
+    message: string;
+}>;
+export type BookingFlowView = Readonly<{
+    kind: "missing";
+    message: string;
+}> | Readonly<{
+    kind: "form";
+}> | Readonly<{
+    kind: "success";
+    message: string;
+    resourceName: string | null;
+}> | Readonly<{
+    kind: "error";
+    message: string;
+}>;
+export type BookingFlowActionResult = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    reason: "validation-failed";
+    errors: BookingValidationErrors;
+}> | Readonly<{
+    ok: false;
+    reason: "blocked";
+    message: string;
+}> | Readonly<{
+    ok: false;
+    reason: "submission-failed";
+    message: string;
+}>;
+export type BookingSubmitOptions = Readonly<{
+    /**
+     * Checkout return URLs apply only to standard paid bookings. Appointment
+     * package submissions complete directly through the portal booking API and
+     * intentionally ignore these URLs.
+     */
+    redirect?: "manual" | "auto";
+    successUrl?: string;
+    cancelUrl?: string;
+}>;
+export type BookingSubmitActionResult = Readonly<{
+    ok: true;
+    outcome: {
+        kind: "booked";
+        appointmentId: string;
+        resourceName: string | null;
+    };
+}> | Readonly<{
+    ok: true;
+    outcome: {
+        kind: "checkout_redirect";
+        checkoutUrl: string;
+    };
+}> | Exclude<BookingFlowActionResult, Readonly<{
+    ok: true;
+}>>;
+export type BookingFieldView = Readonly<{
+    field: BookingFormField;
+    id: string;
+    label: string;
+    type: BookingFormField["type"];
+    value: BookingFieldValue;
+    required: boolean;
+    error: string | null;
+    helpText: string | null;
+    inputId: string;
+    labelId: string;
+    helpTextId: string | null;
+    errorId: string | null;
+    describedBy: string | undefined;
+    ariaInvalid: boolean;
+}>;
+export type BookingFlowReducerState = Readonly<{
+    currentStepId: BookingFlowStepId;
+    selectedServiceId?: string;
+    selectedResourceId?: string;
+    selectedDate?: string;
+    selectedSlot: BookingSlotView | null;
+    fieldValues: Readonly<Record<string, BookingFieldValue>>;
+    touchedFields: Readonly<Record<string, boolean>>;
+    discountCode: string;
+    selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
+    selectedAppointmentPackageId?: string;
+    altchaSolution: string | null;
+    validationErrors: BookingValidationErrors;
+    feedback: BookingFlowFeedback;
+    isSubmitting: boolean;
+}>;
+export type BookingFlowEvent = Readonly<{
+    type: "service-selected";
+    serviceId: string;
+}> | Readonly<{
+    type: "resource-selected";
+    resourceId: string | null;
+}> | Readonly<{
+    type: "date-selected";
+    date: string | null;
+}> | Readonly<{
+    type: "slot-selected";
+    slot: BookingSlotView | null;
+}> | Readonly<{
+    type: "field-updated";
+    fieldId: string;
+    value: BookingFieldValue;
+}> | Readonly<{
+    type: "field-touched";
+    fieldId: string;
+}> | Readonly<{
+    type: "payment-option-selected";
+    kind: BookingSelectedCollectionOptionKind | null;
+}> | Readonly<{
+    type: "appointment-package-selected";
+    packageId: string | null;
+}> | Readonly<{
+    type: "discount-code-changed";
+    code: string;
+}> | Readonly<{
+    type: "altcha-solution-set";
+    solution: string | null;
+}> | Readonly<{
+    type: "altcha-solution-invalidated";
+}> | Readonly<{
+    type: "step-changed";
+    stepId: BookingFlowStepId;
+}> | Readonly<{
+    type: "validation-errors-set";
+    errors: BookingValidationErrors;
+}> | Readonly<{
+    type: "feedback-set";
+    feedback: BookingFlowFeedback;
+}> | Readonly<{
+    type: "availability-selection-invalidated";
+    invalidation: Exclude<AvailabilitySelectionInvalidation, {
+        kind: "preserve";
+    }>;
+}> | Readonly<{
+    type: "feedback-cleared";
+}> | Readonly<{
+    type: "submission-started";
+}> | Readonly<{
+    type: "submission-finished";
+}> | Readonly<{
+    type: "reset";
+    initial: BookingFlowReducerState;
+}>;
+export type BuildBookingStepPlanInput = Readonly<{
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    data: Partial<BookingFormData>;
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    enableAppointmentPackages?: boolean;
+}>;
+export type BookingStepPlanItem = Readonly<{
+    id: BookingFlowStepId;
+    label: string;
+    visible: boolean;
+}>;
+export type BookingStepValidationResult = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    errors: BookingValidationErrors;
+}>;
+export type DeriveBookingFlowStepsInput = Readonly<{
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    data: Partial<BookingFormData>;
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    currentStepId: BookingFlowStepId;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    enableAppointmentPackages?: boolean;
+}>;
+export type DerivedBookingFlowSteps = Readonly<{
+    steps: readonly BookingFlowStep[];
+    currentStepIndex: number;
+    currentStep: BookingFlowStep | null;
+    stepIds: readonly BookingFlowStepId[];
+    validations: ReadonlyMap<BookingFlowStepId, BookingStepValidationResult>;
+}>;
+export type BookingAvailabilityQuery = Readonly<{
+    ok: true;
+    key: string;
+    serviceId: string;
+    resourceId?: string;
+    selectedDate?: string;
+    timezone: string;
+}> | Readonly<{
+    ok: false;
+    reason: "missing-service" | "missing-date";
+    key: string;
+}>;
+export type BookingSubmitRedirectMode = "manual" | "auto";
+export type BookingSubmitPlan = Readonly<{
+    ok: true;
+    redirect: BookingSubmitRedirectMode;
+    value: BookingSubmissionData;
+}> | Readonly<{
+    ok: false;
+    errors: BookingValidationErrors;
+    message: string;
+}>;
+export type BookingAppointmentPackagesModel = Readonly<{
+    kind: "disabled";
+    enabled: false;
+    canLoad: false;
+    unavailableReason: "disabled";
+    state: Readonly<{
+        tag: "idle";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "unavailable";
+    enabled: true;
+    canLoad: false;
+    unavailableReason: "missing-portal-auth" | "missing-priced-service";
+    state: Readonly<{
+        tag: "idle";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "idle";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "idle";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "loading";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "loading";
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "error";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "error";
+        message: string;
+    }>;
+    items: readonly [];
+    selected: null;
+}> | Readonly<{
+    kind: "ready";
+    enabled: true;
+    canLoad: true;
+    unavailableReason: null;
+    state: Readonly<{
+        tag: "loaded";
+        value: readonly EligibleAppointmentPackage[];
+    }>;
+    items: readonly EligibleAppointmentPackage[];
+    selected: EligibleAppointmentPackage | null;
+}>;
+export type BookingAppointmentPackagesUnavailableReason = "disabled" | "missing-portal-auth" | "missing-priced-service";
+export type AppointmentBookingOverrideData = Readonly<{
+    form?: BookingFormConfig | Record<string, unknown> | null;
+    services?: BookingFormServicesSource | Record<string, unknown> | null;
+}>;
+export type AppointmentBookingOverrideContent = Readonly<{
+    formId?: string;
+    serviceId?: string;
+    resourceId?: string;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    shouldAutoSelectSingleResource?: boolean;
+    spamProtectionEnabled?: boolean;
+    successMessage?: string;
+}>;
+export type AppointmentBookingOverridePropsLike = Readonly<{
+    content?: AppointmentBookingOverrideContent | null;
+    data?: AppointmentBookingOverrideData | Record<string, unknown> | null;
+    siteId?: string;
+    apiBaseUrl?: string;
+    portalToken?: string | null;
+    blockId?: string | null;
+}>;
+export type AppointmentBookingOverrideInput = Readonly<{
+    siteId: string;
+    apiBaseUrl: string;
+    portalToken: string | null;
+    formId: string;
+    form: BookingFormConfig;
+    services: readonly BookingFormService[];
+    initialServiceId?: string;
+    initialResourceId?: string;
+    requiresServiceSelection: boolean;
+    requiresResourceSelection: boolean;
+    shouldAutoSelectSingleResource: boolean;
+    spamProtectionEnabled?: boolean;
+    successMessage?: string;
+    blockId?: string | null;
+}>;
+export type AppointmentBookingOverrideInputResult = Readonly<{
+    ok: true;
+    value: AppointmentBookingOverrideInput;
+}> | Readonly<{
+    ok: false;
+    reason: "missing-site-id" | "missing-api-base-url" | "missing-form" | "missing-form-id" | "missing-services";
+    message: string;
+}>;
+export declare function createEmptyBookingValidationErrors(): BookingValidationErrors;
+export declare function createFormBookingValidationError(formError: string): BookingValidationErrors;
+export declare function createFieldBookingValidationErrors(fieldErrors: Readonly<Record<string, string>>): BookingValidationErrors;
+export declare function hasBookingValidationErrors(errors: BookingValidationErrors): boolean;
+export declare function createInitialBookingFlowReducerState(input: Readonly<{
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    initialData?: Partial<BookingFormData>;
+}>): BookingFlowReducerState;
+export declare function bookingFlowReducer(state: BookingFlowReducerState, event: BookingFlowEvent): BookingFlowReducerState;
+export declare function resolveAvailabilitySelectionInvalidation(input: Readonly<{
+    selectedDate?: string;
+    selectedSlot: BookingSlotView | null;
+    availableDates: readonly string[];
+    slots: readonly BookingSlotView[];
+}>): AvailabilitySelectionInvalidation;
+export declare function toBookingSlotView(slot: TimeSlot): BookingSlotView;
+export declare function toBookingSlotViews(slots: readonly TimeSlot[]): BookingSlotView[];
+export declare function toBookingFormData(state: BookingFlowReducerState): BookingFormData;
+export declare function buildBookingStepPlan(input: BuildBookingStepPlanInput): readonly BookingStepPlanItem[];
+export declare function validateBookingStep(input: Readonly<{
+    stepId: BookingFlowStepId;
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    data: Partial<BookingFormData>;
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    requiresResourceSelection?: boolean;
+    paymentResolution?: BookingPaymentStepResolution;
+}>): BookingStepValidationResult;
+export declare function validateBookingFields(input: Readonly<{
+    fields: readonly BookingFormField[];
+    values: Readonly<Record<string, unknown>>;
+}>): Record<string, string>;
+export declare function validateBookingField(field: BookingFormField, value: unknown): string | null;
+export declare function deriveBookingFlowSteps(input: DeriveBookingFlowStepsInput): DerivedBookingFlowSteps;
+export declare function buildBookingAvailabilityQuery(input: Readonly<{
+    serviceId?: string;
+    resourceId?: string;
+    selectedDate?: string;
+    timezone: string;
+    requireDate?: boolean;
+}>): BookingAvailabilityQuery;
+export declare function deriveBookingFieldViews(input: Readonly<{
+    form: BookingFormConfig | null;
+    values: Readonly<Record<string, BookingFieldValue>>;
+    errors: Readonly<Record<string, string>>;
+    touched?: Readonly<Record<string, boolean>>;
+    idPrefix: string;
+}>): readonly BookingFieldView[];
+export declare function buildBookingSubmitPlan(input: Readonly<{
+    formId: string;
+    form: BookingFormConfig | null;
+    state: BookingFlowReducerState;
+    services: readonly BookingFormService[];
+    defaultServiceId?: string;
+    defaultResourceId?: string;
+    requiresResourceSelection?: boolean;
+    altchaSolution?: string | null;
+    viewerTimeZone: string;
+    redirect: BookingSubmitRedirectMode;
+    successUrl?: string;
+    cancelUrl?: string;
+}>): BookingSubmitPlan;
+export declare function getAppointmentBookingOverrideInput(props: AppointmentBookingOverridePropsLike): AppointmentBookingOverrideInputResult;
+export declare function createBookingBlockApiConfig(input: Readonly<{
+    siteId: string;
+    apiBaseUrl: string;
+    portalToken?: string | null;
+}>): BlockApiConfig;
+export declare function resolveHeadlessBookingSelectedService(input: Readonly<{
+    state: BookingFlowReducerState;
+    services: readonly BookingFormService[];
+    defaultServiceId?: string;
+}>): BookingFormService | null;
+export declare function resolveAppointmentPackagesModel(input: Readonly<{
+    enabled: boolean;
+    canLoad: boolean;
+    unavailableReason: BookingAppointmentPackagesUnavailableReason | null;
+    state: LoadState<readonly EligibleAppointmentPackage[]>;
+    items: readonly EligibleAppointmentPackage[];
+    selected: EligibleAppointmentPackage | null;
+}>): BookingAppointmentPackagesModel;
+export declare function resolveHeadlessBookingStatus(input: Readonly<{
+    feedback: BookingFlowFeedback;
+    isSubmitting: boolean;
+}>): BookingFlowStatus;
+export declare function resolveHeadlessBookingView(input: Readonly<{
+    form: BookingFormConfig | null;
+    feedback: BookingFlowFeedback;
+}>): BookingFlowView;
+export declare function describeUnknownError(error: unknown, fallback: string): string;

package/dist/_dts/blocks/src/system/runtime/nodes/booking-form.state.d.ts

@@ -50,6 +50,7 @@ export type BookingFormSourceRecord = Readonly<{
     createdAt: string;
     updatedAt: string;
 }>;
+export type BookingFormConfigSource = BookingFormConfig | BookingFormSourceRecord | Readonly<Record<string, unknown>>;
 type BlockBookingPaymentTermsAvailability = Readonly<{
     kind: "available";
     paymentTerms: BlockBookingPaymentTerms;
@@ -196,8 +197,10 @@ export declare function deriveBookingFormViewState(input: Readonly<{
     verificationState: AppointmentCheckoutVerificationState;
 }>): BookingFormViewState;
 export declare function resolveBookingSiteId(siteId: string | undefined, form: BookingFormSourceRecord | null | undefined): string;
-export declare function normalizeBookingFormConfig(form: BookingFormSourceRecord | null | undefined): BookingFormConfig | null;
-export declare function normalizeBookingServices(services: BookingFormServicesSource | null | undefined): readonly BookingFormService[];
+export declare function normalizeBookingFormConfig(form: unknown): BookingFormConfig | null;
+export declare function normalizeBookingServices(services: unknown): readonly BookingFormService[];
+export declare const BOOKING_FORM_DATA_RESERVED_KEYS: Set<string>;
+export declare function toSelectedCollectionOptionKind(value: unknown): BookingSelectedCollectionOptionKind | undefined;
 export declare function getBookingServicePaymentSelectionMode(service: BookingFormService | undefined): BookingPaymentSelectionMode;
 export declare function resolveDefaultBookingServiceId(formConfig: BookingFormConfig | null | undefined, services: readonly BookingFormService[]): string | null;
 export declare function resolveBookingSelectedService(input: Readonly<{

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/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/site-commands/commandRuntime.d.ts

@@ -1,7 +1,6 @@
 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';
-import { type SyncResult } from '../sync';
 export type CliCommandBatchRefInput<TSource extends string = string> = Readonly<{
     source: TSource;
     siteId: SiteId;
@@ -46,7 +45,32 @@ export type CliCommandExecutionReportFailure<TSubject> = Readonly<{
     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[];
@@ -94,21 +118,27 @@ export declare function commandExecutionToReport<TCommand extends Readonly<{
     commandDisplayIdentifier: (command: TCommand) => string;
     includeFailureSubject?: boolean;
 }>): CliCommandExecutionReport<TSubject>;
-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<{
+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>(input: Readonly<{
+}>, TExecutionResult, TSubject>(input: Readonly<{
     compiledPlan: TCompiledPlan;
     onBeforeExecute?: (commandCount: number) => void;
     executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
-    executionToSyncResult: (input: Readonly<{
+    executionToReport: (input: Readonly<{
         execution: TExecutionResult;
         compiledPlan: TCompiledPlan;
-    }>) => SyncResult;
-}>): Promise<SyncResult>;
+    }>) => 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;