@riverbankcms/sdk 0.67.0 → 0.68.0

package/dist/_dts/billing/src/components/index.d.ts

@@ -0,0 +1,426 @@
+import { type BillingPlanId } from '../plans/types';
+export type BillingComponentInterval = 'month' | 'year';
+export type BillingComponentCurrencyCode = string;
+export type BillingComponentId = string;
+export type BillingComponentSiteId = string;
+export type BillingComponentSiteDomainId = string;
+export type BillingComponentKind = 'plan_base' | 'custom_site_price' | 'extra_site' | 'managed_domain_overage';
+export type BillingComponentProposalPlan = Readonly<{
+    idempotencyKey: string;
+    pendingSourceKey: string;
+    userId: string;
+    siteId: string | null;
+    kind: 'extra_site' | 'managed_domain_overage';
+    amountCents: number;
+    currency: string;
+    interval: BillingComponentInterval;
+    sourceEntity: BillingComponentSourceEntityPlan;
+    snapshotHash: string;
+    pricingSnapshot: unknown;
+}>;
+export type BillingComponentSourceEntityPlan = Readonly<{
+    type: 'site';
+    id: string;
+}> | Readonly<{
+    type: 'site_domain';
+    id: string | null;
+}>;
+export type BillingComponentOrigin = 'computed' | 'planned' | 'persisted';
+export type BillingComponentPlanSource = Readonly<{
+    kind: 'plan';
+    planId: string;
+}>;
+export type BillingComponentSiteSource = Readonly<{
+    kind: 'site';
+    siteId: BillingComponentSiteId;
+}>;
+export type BillingComponentSiteDomainSource = Readonly<{
+    kind: 'site_domain';
+    siteId: BillingComponentSiteId;
+    siteDomainId: BillingComponentSiteDomainId;
+}>;
+export type BillingComponentSource = BillingComponentPlanSource | BillingComponentSiteSource | BillingComponentSiteDomainSource;
+export type BillingComponentSourceForKind<TKind extends BillingComponentKind> = TKind extends 'plan_base' ? BillingComponentPlanSource : TKind extends 'custom_site_price' | 'extra_site' ? BillingComponentSiteSource : TKind extends 'managed_domain_overage' ? BillingComponentSiteDomainSource : never;
+export type BillingComponentBase<TKind extends BillingComponentKind, TOrigin extends BillingComponentOrigin> = Readonly<{
+    origin: TOrigin;
+    kind: TKind;
+    source: BillingComponentSourceForKind<TKind>;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}>;
+export type MacadamiaExtraSiteBillingComponentProposalPlan = BillingComponentProposalPlan & Readonly<{
+    kind: 'extra_site';
+    siteId: string;
+    sourceEntity: Readonly<{
+        type: 'site';
+        id: string;
+    }>;
+    pricingSnapshot: MacadamiaExtraSitePricingSnapshot;
+}>;
+export type ManagedDomainOverageBillingComponentProposalPlan<TPricingSnapshot = unknown> = BillingComponentProposalPlan & Readonly<{
+    kind: 'managed_domain_overage';
+    siteId: string;
+    sourceEntity: Readonly<{
+        type: 'site_domain';
+        id: string | null;
+    }>;
+    pricingSnapshot: TPricingSnapshot;
+}>;
+export type ComputedBillingComponent = (BillingComponentBase<'plan_base', 'computed'> & Readonly<{
+    label: string;
+}>) | (BillingComponentBase<'custom_site_price', 'computed'> & Readonly<{
+    label: string;
+}>);
+export type PlannedPersistedBillingComponent = (BillingComponentBase<'extra_site', 'planned'> & Readonly<{
+    label: string;
+}>) | (BillingComponentBase<'managed_domain_overage', 'planned'> & Readonly<{
+    label: string;
+}>);
+export type PersistedBillingComponent = BillingComponentBase<'extra_site', 'persisted'> | BillingComponentBase<'managed_domain_overage', 'persisted'>;
+export type BillingComponent = ComputedBillingComponent | PlannedPersistedBillingComponent | PersistedBillingComponent;
+export type BillingModelDecision = Readonly<{
+    kind: 'macadamia_user_plan';
+    reason: 'no_custom_site_prices';
+}> | Readonly<{
+    kind: 'custom_site_billing';
+    reason: 'active_custom_site_prices';
+}>;
+export type BillingComponentResolution = Readonly<{
+    model: BillingModelDecision;
+    components: readonly BillingComponent[];
+    basePlanCents: number;
+    customSitePricesCents: number;
+    extraSiteCents: number;
+    recurringAddOnsCents: number;
+    totalCents: number;
+}>;
+export type BillingSiteCostBreakdown = Readonly<{
+    siteId: BillingComponentSiteId;
+    siteName: string;
+    costCents: number;
+    billingStartsAt: string | null;
+}>;
+export type BillingBasePricePlan = Readonly<{
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    isCustomPrice: boolean;
+    source: 'override' | 'base';
+}>;
+export type BillingTotalPricePlan = BillingBasePricePlan & Readonly<{
+    billingModel: BillingModelDecision;
+    basePlanCents: number;
+    customSitePricesCents: number;
+    extraSiteCents: number;
+    recurringAddOnsCents: number;
+    totalCents: number;
+    siteBreakdown: readonly BillingSiteCostBreakdown[];
+    componentBreakdown: readonly BillingComponent[];
+}>;
+export type BillingComponentCompatibilityMismatch = Readonly<{
+    tag: 'component_interval_currency_mismatch';
+    componentInterval: BillingComponentInterval;
+    requestedInterval: BillingComponentInterval;
+    componentCurrency: BillingComponentCurrencyCode;
+    requestedCurrency: BillingComponentCurrencyCode;
+}>;
+export type BillingTotalPricePlanError = Readonly<{
+    tag: 'base_price_required';
+}> | Readonly<{
+    tag: 'hybrid_billing_forbidden';
+    customSiteIds: readonly string[];
+    extraSiteIds: readonly string[];
+}>;
+export type BillingTotalPricePlanResult = Readonly<{
+    success: true;
+    data: BillingTotalPricePlan;
+}> | Readonly<{
+    success: false;
+    error: BillingTotalPricePlanError;
+}>;
+export type BillingComponentSummaryBase<TKind extends BillingComponentKind> = Readonly<{
+    kind: TKind;
+    label: string;
+    amountCents: number;
+    formatted: string;
+    interval: BillingComponentInterval;
+}>;
+export type BillingComponentSummaryBasePlanComponent = BillingComponentSummaryBase<'plan_base'> & Readonly<{
+    source: BillingComponentPlanSource;
+}>;
+export type BillingComponentSummarySiteComponent = BillingComponentSummaryBase<'custom_site_price'> & Readonly<{
+    source: BillingComponentSiteSource;
+}>;
+export type BillingComponentSummaryAddOnComponent = (BillingComponentSummaryBase<'extra_site'> & Readonly<{
+    source: BillingComponentSiteSource;
+}>) | (BillingComponentSummaryBase<'managed_domain_overage'> & Readonly<{
+    source: BillingComponentSiteDomainSource;
+}>);
+export type BillingComponentSummaryComponent = BillingComponentSummaryBasePlanComponent | BillingComponentSummarySiteComponent | BillingComponentSummaryAddOnComponent;
+export type BillingComponentSummary = Readonly<{
+    basePlan: BillingComponentSummaryBasePlanComponent | null;
+    sites: BillingComponentSummarySiteComponent[];
+    addOns: BillingComponentSummaryAddOnComponent[];
+    total: Readonly<{
+        amountCents: number;
+        formatted: string;
+    }>;
+    isCustomPrice: boolean;
+}>;
+export type BillingComponentSummaryError = Readonly<{
+    tag: 'missing_component_label';
+    componentKind: PersistedBillingComponent['kind'];
+    sourceId: string;
+}>;
+export type BillingComponentSummaryResult = Readonly<{
+    success: true;
+    data: BillingComponentSummary;
+}> | Readonly<{
+    success: false;
+    error: BillingComponentSummaryError;
+}>;
+export type BillingComponentSummaryFormatter = (amountCents: number, currency: BillingComponentCurrencyCode) => string;
+export type BillingComponentSummaryLabelRequirements = Readonly<{
+    extraSiteIds: readonly BillingComponentSiteId[];
+    siteDomainIds: readonly BillingComponentSiteDomainId[];
+}>;
+export type BillableSiteState = Readonly<{
+    tag: 'draft';
+}> | Readonly<{
+    tag: 'billable_live';
+    launchedAt: string;
+}> | Readonly<{
+    tag: 'not_billable';
+    reason: 'archived' | 'deleted';
+}>;
+export type BillableMacadamiaSite = Readonly<{
+    siteId: BillingComponentSiteId;
+    siteName: string;
+    state: BillableSiteState;
+    grandfathered?: boolean;
+}>;
+export type MacadamiaExtraSitePricingSnapshot = Readonly<{
+    formulaVersion: 'macadamia-extra-site-v1';
+    planId: BillingPlanId;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}>;
+export type ExtraSitePricingPolicy = Readonly<{
+    includedSiteCount: number;
+    currency: BillingComponentCurrencyCode;
+    extraSite: Readonly<{
+        tag: 'not_supported';
+    }> | Readonly<{
+        tag: 'priced';
+        monthlyAmountCents: number;
+    }>;
+}>;
+export type ConfiguredExtraSitePricingPolicy = ExtraSitePricingPolicy & Readonly<{
+    extraSite: Readonly<{
+        tag: 'priced';
+        monthlyAmountCents: number;
+    }>;
+}>;
+export type ActiveExtraSiteComponentForReconciliation = Readonly<{
+    componentId: BillingComponentId;
+    siteId: BillingComponentSiteId;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}>;
+export type MacadamiaExtraSiteReconciliationAction = Readonly<{
+    tag: 'requires_acceptance';
+    site: BillableMacadamiaSite;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}> | Readonly<{
+    tag: 'create_missing';
+    site: BillableMacadamiaSite;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}> | Readonly<{
+    tag: 'end_at_period_end';
+    component: ActiveExtraSiteComponentForReconciliation;
+    reason: 'site_no_longer_billable' | 'site_within_allowance' | 'site_grandfathered';
+}> | Readonly<{
+    tag: 'invalid_state';
+    reason: 'duplicate_active_component';
+    siteId?: BillingComponentSiteId;
+}> | Readonly<{
+    tag: 'requires_plan_upgrade';
+    site: BillableMacadamiaSite;
+    minimumPlanId: 'solo';
+}>;
+export type MacadamiaExtraSiteReconciliationPlan = Readonly<{
+    tag: 'no_change';
+}> | Readonly<{
+    tag: 'changes_required';
+    actions: readonly MacadamiaExtraSiteReconciliationAction[];
+}>;
+export type MacadamiaExtraSiteLaunchDecision = Readonly<{
+    tag: 'allowed';
+    reason: 'within_included_allowance';
+}> | Readonly<{
+    tag: 'allowed';
+    reason: 'accepted_extra_site_component';
+    componentId?: BillingComponentId;
+}> | Readonly<{
+    tag: 'requires_plan_upgrade';
+    currentPlanId: BillingPlanId;
+    minimumPlanId: 'solo';
+}> | Readonly<{
+    tag: 'requires_acceptance';
+    currentPlanId: BillingPlanId;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}>;
+export type MacadamiaSiteCreationBillingNotice = Readonly<{
+    tag: 'none';
+    reason: 'within_included_allowance' | 'accepted_extra_site_component';
+}> | Readonly<{
+    tag: 'unknown';
+    reason: 'billing_lookup_failed';
+}> | Readonly<{
+    tag: 'upgrade_required_on_launch';
+    currentPlanId: BillingPlanId;
+    minimumPlanId: 'solo';
+}> | Readonly<{
+    tag: 'extra_site_charge_on_launch';
+    currentPlanId: BillingPlanId;
+    amountCents: number;
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}>;
+export type MacadamiaExtraSiteProposalDecisionPlan = Extract<MacadamiaExtraSiteLaunchDecision, {
+    tag: 'requires_acceptance';
+}>;
+export declare function resolveBillableSiteState(input: Readonly<{
+    launchedAt: string | null;
+    archivedAt?: string | null;
+    deletedAt?: string | null;
+}>): BillableSiteState;
+export declare function classifyBillingModel(input: Readonly<{
+    customSitePrices: readonly BillingComponent[];
+}>): BillingModelDecision;
+export declare function planExtraSiteComponents(input: Readonly<{
+    sites: readonly BillableMacadamiaSite[];
+    policy: ConfiguredExtraSitePricingPolicy;
+    interval?: BillingComponentInterval;
+}>): readonly BillingComponent[];
+export declare function planMacadamiaExtraSiteReconciliation(input: Readonly<{
+    sites: readonly BillableMacadamiaSite[];
+    activeExtraSiteComponents: readonly ActiveExtraSiteComponentForReconciliation[];
+    acceptedSiteIds?: readonly BillingComponentSiteId[];
+    policy: ExtraSitePricingPolicy;
+    interval?: BillingComponentInterval;
+}>): MacadamiaExtraSiteReconciliationPlan;
+export declare function evaluateMacadamiaExtraSiteLaunchDecision(input: Readonly<{
+    siteId: BillingComponentSiteId;
+    currentPlanId: BillingPlanId;
+    currentLiveSiteCount: number;
+    acceptedExtraSiteComponents?: readonly Readonly<{
+        siteId: BillingComponentSiteId;
+        componentId?: BillingComponentId;
+    }>[];
+    policy: ExtraSitePricingPolicy;
+    interval?: BillingComponentInterval;
+}>): MacadamiaExtraSiteLaunchDecision;
+export declare function macadamiaExtraSiteLaunchDecisionToCreationBillingNotice(decision: MacadamiaExtraSiteLaunchDecision): MacadamiaSiteCreationBillingNotice;
+export declare function evaluateMacadamiaSiteCreationBillingNotice(input: Readonly<{
+    currentPlanId: BillingPlanId;
+    currentLiveSiteCount: number;
+    policy: ExtraSitePricingPolicy;
+    interval?: BillingComponentInterval;
+}>): MacadamiaSiteCreationBillingNotice;
+export declare function resolveBillingComponents(input: Readonly<{
+    basePlan: BillingComponent;
+    customSitePrices: readonly BillingComponent[];
+    extraSites?: readonly BillingComponent[];
+    recurringAddOns?: readonly BillingComponent[];
+}>): BillingComponentResolution;
+export declare function partitionPersistedBillingComponents(components: readonly PersistedBillingComponent[]): Readonly<{
+    extraSites: readonly PersistedBillingComponent[];
+    recurringAddOns: readonly PersistedBillingComponent[];
+}>;
+export declare function toBillingSiteCostBreakdown(input: Readonly<{
+    siteId: string;
+    siteName: string;
+    monthlyCostCents: number;
+    billingStartsAt: string | null;
+}>): BillingSiteCostBreakdown;
+export declare function planCustomSitePriceComponents(input: Readonly<{
+    siteBreakdown: readonly BillingSiteCostBreakdown[];
+    currency: BillingComponentCurrencyCode;
+    interval: BillingComponentInterval;
+}>): readonly BillingComponent[];
+export declare function validateBillingComponentCompatibility(input: Readonly<{
+    component: BillingComponent;
+    requestedInterval: BillingComponentInterval;
+    requestedCurrency: BillingComponentCurrencyCode;
+}>): BillingComponentCompatibilityMismatch | null;
+export declare function planBillingTotalPrice(input: Readonly<{
+    planId: string;
+    interval: BillingComponentInterval;
+    currency: BillingComponentCurrencyCode;
+    siteBreakdown: readonly BillingSiteCostBreakdown[];
+    persistedComponents: readonly PersistedBillingComponent[];
+    basePrice?: BillingBasePricePlan;
+}>): BillingTotalPricePlanResult;
+export declare function getBillingComponentSummaryLabelRequirements(components: readonly BillingComponent[]): BillingComponentSummaryLabelRequirements;
+export declare function buildBillingComponentSummary(input: Readonly<{
+    components: readonly BillingComponent[];
+    totalCents: number;
+    totalCurrency: BillingComponentCurrencyCode;
+    isCustomPrice: boolean;
+    persistedLabels: ReadonlyMap<string, string>;
+    formatAmount: BillingComponentSummaryFormatter;
+}>): BillingComponentSummaryResult;
+export declare function toBillingComponentSummaryComponent(component: BillingComponent, persistedLabels: ReadonlyMap<string, string>, formatAmount: BillingComponentSummaryFormatter): Readonly<{
+    success: true;
+    data: BillingComponentSummaryComponent;
+} | {
+    success: false;
+    error: BillingComponentSummaryError;
+}>;
+export declare function isBillingComponentSummaryBasePlanComponent(component: BillingComponentSummaryComponent): component is BillingComponentSummaryBasePlanComponent;
+export declare function isBillingComponentSummarySiteComponent(component: BillingComponentSummaryComponent): component is BillingComponentSummarySiteComponent;
+export declare function isBillingComponentSummaryAddOnComponent(component: BillingComponentSummaryComponent): component is BillingComponentSummaryAddOnComponent;
+export declare function persistedBillingComponentLabelKey(component: PersistedBillingComponent): string;
+export declare function persistedBillingComponentLabelKey(kind: PersistedBillingComponent['kind'], sourceId: string): string;
+export declare function parseMacadamiaExtraSitePricingSnapshot(value: unknown): MacadamiaExtraSitePricingSnapshot | null;
+export declare function buildMacadamiaExtraSitePricingSnapshot(decision: MacadamiaExtraSiteProposalDecisionPlan): MacadamiaExtraSitePricingSnapshot;
+export declare function buildMacadamiaExtraSiteProposalPlan(input: Readonly<{
+    billingUserId: string;
+    siteId: string;
+    decision: MacadamiaExtraSiteProposalDecisionPlan;
+}>): MacadamiaExtraSiteBillingComponentProposalPlan;
+export type BillingComponentProposalPlanBranding<TIdempotencyKey, TPendingSourceKey, TUserId, TSiteId, TSnapshotHash, TPricingSnapshot> = Readonly<{
+    idempotencyKey: (value: string) => TIdempotencyKey;
+    pendingSourceKey: (value: string) => TPendingSourceKey;
+    userId: (value: string) => TUserId;
+    siteId: (value: string) => TSiteId;
+    snapshotHash: (value: string) => TSnapshotHash;
+    pricingSnapshot: (value: unknown) => TPricingSnapshot;
+}>;
+export type BillingComponentProposalPricingSnapshotParser<TPricingSnapshot> = (value: unknown) => TPricingSnapshot | null;
+export type BrandedBillingComponentProposalPlan<TIdempotencyKey, TPendingSourceKey, TUserId, TSiteId, TSnapshotHash, TPricingSnapshot> = Omit<BillingComponentProposalPlan, 'idempotencyKey' | 'pendingSourceKey' | 'userId' | 'siteId' | 'snapshotHash' | 'pricingSnapshot'> & Readonly<{
+    idempotencyKey: TIdempotencyKey;
+    pendingSourceKey: TPendingSourceKey;
+    userId: TUserId;
+    siteId: TSiteId | null;
+    snapshotHash: TSnapshotHash;
+    pricingSnapshot: TPricingSnapshot;
+}>;
+export declare function asBillingComponentProposalPlan<TIdempotencyKey, TPendingSourceKey, TUserId, TSiteId, TSnapshotHash, TPricingSnapshot>(plan: BillingComponentProposalPlan, brand: BillingComponentProposalPlanBranding<TIdempotencyKey, TPendingSourceKey, TUserId, TSiteId, TSnapshotHash, TPricingSnapshot>): BrandedBillingComponentProposalPlan<TIdempotencyKey, TPendingSourceKey, TUserId, TSiteId, TSnapshotHash, TPricingSnapshot>;
+/**
+ * Fail-fast guard for static proposal brand adapters. The parser boundary should
+ * be wired during service construction, so returning a Result would only move a
+ * programming/configuration error into every runtime caller.
+ */
+export declare function asBillingComponentProposalPricingSnapshot<TPricingSnapshot>(value: unknown, parse: BillingComponentProposalPricingSnapshotParser<TPricingSnapshot>, description?: string): TPricingSnapshot;
+export declare function hashBillingComponentSnapshot(snapshot: unknown): string;
+export declare function stableJson(value: unknown): string;

package/dist/_dts/blocks/src/PageRenderer.d.ts

@@ -86,6 +86,10 @@ export type BlockOverrideProps<TContent = Record<string, unknown>> = {
     data?: Record<string, unknown>;
     /** Site UUID (useful for media URL resolution in override components) */
     siteId?: string;
+    /** Dashboard API URL for client-side block runtime calls. */
+    apiBaseUrl?: string;
+    /** Customer portal token for Bearer-authenticated block runtime calls. */
+    portalToken?: string | null;
     /** Supabase project URL (useful for media URL resolution in override components) */
     supabaseUrl?: string;
     /** Full image-resolution context including canonical media sidecars. */

package/dist/_dts/blocks/src/client.d.ts

@@ -10,11 +10,14 @@
 export { BlockApiProvider, useBlockApi, type BlockApiConfig } from './system/runtime/api';
 export { clientComponentRegistry } from './system/runtime/components/registry.client';
 export type { ComponentRegistry } from './system/runtime/resolver';
+export type { BookingPaymentOptionViewModel, BookingPaymentSelectionViewModel, } from './system/runtime/shared/bookingPaymentOptions';
 export { enhanceHeaderSection } from './system/runtime/header/enhanceHeaderSection';
 export { ClientThemeScope } from '@riverbankcms/theme-core/ClientThemeScope';
 export { ImageResolveContextProvider, useImageResolveContextOptional, } from './system/runtime/nodes/ImageResolveContext';
 export { FormNodeClient } from './system/runtime/nodes/form.client';
 export { BookingFormClient } from './system/runtime/nodes/booking-form.client';
+export { HeadlessBookingProvider, createBookingBlockApiConfig, useHeadlessBookingFlow, } from './system/runtime/hooks/useHeadlessBookingFlow';
+export { AltchaWidget as HeadlessBookingAltchaWidget } from '@riverbankcms/altcha/client';
 export { EventRegistrationClient, EventRegistrationIslandClient } from './system/runtime/nodes/event-registration.client';
 export { EventDetailsClient, EventDetailsIslandClient } from './system/runtime/nodes/event-details.client';
 export { LocationMapClient, LocationMapIslandClient } from './system/runtime/nodes/location-map.client';
@@ -25,6 +28,9 @@ export { normalizeCarouselProps } from './system/runtime/nodes/carousel.client';
 export type { CarouselNodeClientProps, NormalizedCarouselProps, ResponsiveSlidesToShow, } from './system/runtime/nodes/carousel.client';
 export { MediaNode, type MediaNodeProps } from './system/runtime/nodes/media.client';
 export type { BookingFormClientProps, FormConfig as BookingFormConfig, Service as BookingService, } from './system/runtime/nodes/booking-form.client';
+export type { BookingAvailabilityModel, BookingAppointmentPackagesModel, BookingDiscountModel, BookingFieldsModel, BookingFlowActions, BookingPaymentModel, BookingResourcesModel, BookingServicesModel, BookingSpamProtectionModel, HeadlessBookingFlow, HeadlessBookingFlowOptions, HeadlessBookingProviderProps, } from './system/runtime/hooks/useHeadlessBookingFlow';
+export type { AppointmentBookingOverrideData, AppointmentBookingOverrideInput, AppointmentBookingOverrideInputResult, AppointmentBookingOverridePropsLike, BookingAvailabilityQuery, BookingAppointmentPackagesUnavailableReason, BookingFieldValue, BookingFieldView, BookingFlowActionResult, BookingFlowFeedback, BookingFlowStatus, BookingFlowView, BookingResourceView, BookingFlowStep, BookingFlowStepId, BookingSlotView, BookingSubmitActionResult, BookingSubmitOptions, BookingValidationErrors, DerivedBookingFlowSteps, DeriveBookingFlowStepsInput, LoadState, } from './system/runtime/hooks/useHeadlessBookingFlow.state';
+export { buildBookingAvailabilityQuery, buildBookingStepPlan, buildBookingSubmitPlan, createEmptyBookingValidationErrors, createFieldBookingValidationErrors, createFormBookingValidationError, describeUnknownError, deriveBookingFlowSteps, deriveBookingFieldViews, getAppointmentBookingOverrideInput, hasBookingValidationErrors, resolveAppointmentPackagesModel, resolveHeadlessBookingStatus, resolveHeadlessBookingView, toBookingFormData, toBookingSlotView, toBookingSlotViews, validateBookingField, validateBookingFields, validateBookingStep, } from './system/runtime/hooks/useHeadlessBookingFlow.state';
 export type { EventDetailsClientProps, EventDetailsIslandClientProps } from './system/runtime/nodes/event-details.client';
 export type { LocationMapClientProps, LocationMapIslandClientProps } from './system/runtime/nodes/location-map.client';
 export type { EventRegistrationClientProps, EventRegistrationIslandClientProps, } from './system/runtime/nodes/event-registration.client';

package/dist/_dts/blocks/src/system/runtime/hooks/useAvailableDates.d.ts

@@ -17,6 +17,7 @@ export type UseAvailableDatesOptions = {
 export type UseAvailableDatesResult = {
     availableDates: Set<string>;
     isLoading: boolean;
+    isRefreshing: boolean;
     error: string | null;
     hasMore: boolean;
     loadMore: () => void;

package/dist/_dts/blocks/src/system/runtime/hooks/useAvailableSlots.d.ts

@@ -4,7 +4,7 @@
  * Uses the Block API Client for type-safe API calls.
  * Must be used within a BlockApiProvider.
  */
-import { type TimeSlot } from '../api';
+import { type TimeSlot } from "../api";
 export type { TimeSlot };
 type UseAvailableSlotsOptions = {
     siteId: string;
@@ -16,6 +16,8 @@ type UseAvailableSlotsOptions = {
 type UseAvailableSlotsResult = {
     slots: TimeSlot[];
     isLoading: boolean;
+    isRefreshing: boolean;
+    hasLoaded: boolean;
     error: string | null;
 };
 /**

package/dist/_dts/blocks/src/system/runtime/hooks/useHeadlessBookingFlow.d.ts

@@ -0,0 +1,140 @@
+import React from "react";
+import { type BlockApiConfig } from "../api";
+import type { AutoAppliedDiscountPreview } from "../api/types";
+import type { BookingFormConfig, BookingFormData, BookingFormService, BookingSelectedCollectionOptionKind } from "../nodes/booking-form.state";
+import { type BookingPaymentSelectionViewModel } from "../shared/bookingPaymentOptions";
+import { createBookingBlockApiConfig, type BookingAppointmentPackagesModel, type BookingFieldValue, type BookingFieldView, type BookingFlowActionResult, type BookingFlowFeedback, type BookingFlowStatus, type BookingFlowView, type BookingResourceView, type BookingFlowStep, type BookingFlowStepId, type BookingSlotView, type BookingSubmitActionResult, type BookingSubmitOptions, type LoadState } from "./useHeadlessBookingFlow.state";
+export type { BlockApiConfig };
+export type { BookingAppointmentPackagesModel };
+export { createBookingBlockApiConfig };
+export type HeadlessBookingFlowOptions = Readonly<{
+    siteId: string;
+    formId: string;
+    form: BookingFormConfig | null;
+    services: readonly BookingFormService[];
+    initialServiceId?: string;
+    initialResourceId?: string;
+    initialData?: Partial<BookingFormData>;
+    requiresServiceSelection?: boolean;
+    requiresResourceSelection?: boolean;
+    shouldAutoSelectSingleResource?: boolean;
+    enableAppointmentPackages?: boolean;
+    spamProtectionEnabled?: boolean;
+    successMessage?: string;
+    anchorId?: string;
+    viewerTimeZone?: string;
+    navigateToCheckout?: (checkoutUrl: string) => void;
+}>;
+export type BookingServicesModel = Readonly<{
+    items: readonly BookingFormService[];
+    selected: BookingFormService | null;
+    defaultServiceId?: string;
+    requiresSelection: boolean;
+}>;
+export type BookingResourcesModel = Readonly<{
+    items: readonly BookingResourceView[];
+    selected: BookingResourceView | null;
+    selectedResourceId?: string;
+    state: LoadState<readonly BookingResourceView[]>;
+    requiresSelection: boolean;
+}>;
+export type BookingAvailabilityModel = Readonly<{
+    selectedDate?: string;
+    availableDates: readonly string[];
+    selectedSlot: BookingSlotView | null;
+    slots: readonly BookingSlotView[];
+    datesState: LoadState<readonly string[]>;
+    slotsState: LoadState<readonly BookingSlotView[]>;
+    timezone: string;
+    hasMoreDates: boolean;
+    loadMoreDates: () => void;
+}>;
+export type BookingFieldsModel = Readonly<{
+    items: readonly BookingFieldView[];
+    values: Readonly<Record<string, BookingFieldValue>>;
+    errors: Readonly<Record<string, string>>;
+    touched: Readonly<Record<string, boolean>>;
+}>;
+export type BookingPaymentModel = Readonly<{
+    kind: "unsupported";
+    mode: "unsupported";
+    selection: null;
+    selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
+    selectedAppointmentPackageId?: string;
+    appointmentPackages: BookingAppointmentPackagesModel;
+    errorMessage: string;
+}> | Readonly<{
+    kind: "ok";
+    mode: "hidden" | "disclosure_only" | "choice_required";
+    selection: BookingPaymentSelectionViewModel | null;
+    selectedCollectionOptionKind?: BookingSelectedCollectionOptionKind;
+    selectedAppointmentPackageId?: string;
+    appointmentPackages: BookingAppointmentPackagesModel;
+}>;
+export type BookingDiscountModel = Readonly<{
+    code: string;
+    isOpen: boolean;
+    manualCodeEntryAllowed: boolean;
+    loading: boolean;
+    autoAppliedDiscount: AutoAppliedDiscountPreview | null;
+    setCode: (code: string) => void;
+    setOpen: (isOpen: boolean) => void;
+    clear: () => void;
+}>;
+export type BookingSpamProtectionModel = Readonly<{
+    enabled: false;
+}> | Readonly<{
+    enabled: true;
+    provider: "altcha";
+    challenge: {
+        url: string;
+        auto: "onfocus";
+    };
+    solution: string | null;
+}>;
+export type BookingFlowActions = Readonly<{
+    selectService: (serviceId: string) => void;
+    selectResource: (resourceId: string | null) => void;
+    selectDate: (date: string | null) => void;
+    selectSlot: (slot: BookingSlotView | null) => void;
+    updateField: (fieldId: string, value: BookingFieldValue) => void;
+    markFieldTouched: (fieldId: string) => void;
+    selectPaymentOption: (kind: BookingSelectedCollectionOptionKind | null) => void;
+    selectAppointmentPackage: (packageId: string | null) => void;
+    setDiscountCode: (code: string) => void;
+    clearDiscountCode: () => void;
+    setAltchaSolution: (solution: string | null) => void;
+    invalidateSpamProtection: () => void;
+    next: () => Promise<BookingFlowActionResult>;
+    back: () => void;
+    /**
+     * Moves to a visible step without validating previous steps. Consumers that
+     * want linear progression should consult `steps[].canEnter` or call `next()`.
+     */
+    goToStep: (stepId: BookingFlowStepId) => Promise<BookingFlowActionResult>;
+    submit: (options?: BookingSubmitOptions) => Promise<BookingSubmitActionResult>;
+    reset: () => void;
+    clearFeedback: () => void;
+}>;
+export type HeadlessBookingFlow = Readonly<{
+    status: BookingFlowStatus;
+    view: BookingFlowView;
+    steps: readonly BookingFlowStep[];
+    currentStep: BookingFlowStep | null;
+    data: Partial<BookingFormData>;
+    services: BookingServicesModel;
+    resources: BookingResourcesModel;
+    availability: BookingAvailabilityModel;
+    fields: BookingFieldsModel;
+    payment: BookingPaymentModel;
+    discount: BookingDiscountModel;
+    spamProtection: BookingSpamProtectionModel;
+    feedback: BookingFlowFeedback;
+    actions: BookingFlowActions;
+}>;
+export type HeadlessBookingProviderProps = Readonly<{
+    config: BlockApiConfig;
+    children?: React.ReactNode;
+}>;
+export declare function HeadlessBookingProvider({ config, children, }: HeadlessBookingProviderProps): React.ReactElement;
+export declare function useHeadlessBookingFlow(options: HeadlessBookingFlowOptions): HeadlessBookingFlow;

package/dist/_dts/blocks/src/system/runtime/hooks/useHeadlessBookingFlow.state.d.ts

@@ -0,0 +1,2 @@
+export { bookingFlowReducer, buildBookingAvailabilityQuery, buildBookingStepPlan, buildBookingSubmitPlan, createBookingBlockApiConfig, createEmptyBookingValidationErrors, createFieldBookingValidationErrors, createFormBookingValidationError, createInitialBookingFlowReducerState, describeUnknownError, deriveBookingFieldViews, deriveBookingFlowSteps, getAppointmentBookingOverrideInput, hasBookingValidationErrors, resolveAppointmentPackagesModel, resolveAvailabilitySelectionInvalidation, resolveHeadlessBookingStatus, resolveHeadlessBookingView, toBookingFormData, toBookingSlotView, toBookingSlotViews, validateBookingField, validateBookingFields, validateBookingStep, } from "../nodes/booking-form.headless.state";
+export type { AppointmentBookingOverrideData, AppointmentBookingOverrideInput, AppointmentBookingOverrideInputResult, AppointmentBookingOverridePropsLike, BookingAvailabilityQuery, BookingAppointmentPackagesModel, BookingAppointmentPackagesUnavailableReason, BookingFieldValue, BookingFieldView, BookingFlowActionResult, BookingFlowFeedback, BookingFlowStatus, BookingFlowStep, BookingFlowStepId, BookingFlowView, BookingResourceView, BookingSlotView, BookingSubmitActionResult, BookingSubmitOptions, BookingValidationErrors, DerivedBookingFlowSteps, DeriveBookingFlowStepsInput, LoadState, } from "../nodes/booking-form.headless.state";

package/dist/_dts/blocks/src/system/runtime/hooks/useVisibleTabPolling.d.ts

@@ -0,0 +1,10 @@
+export declare const MIN_AVAILABILITY_REFRESH_INTERVAL_MS = 15000;
+type UseVisibleTabPollingOptions = {
+    enabled: boolean;
+    intervalMs: number;
+    jitterMs: number;
+    minVisibleRefreshIntervalMs?: number;
+    onPoll: () => Promise<void> | void;
+};
+export declare function useVisibleTabPolling({ enabled, intervalMs, jitterMs, minVisibleRefreshIntervalMs, onPoll, }: UseVisibleTabPollingOptions): void;
+export {};

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

@@ -0,0 +1,8 @@
+import React from "react";
+import type { HeadlessBookingFlow } from "../hooks/useHeadlessBookingFlow";
+type HeadlessBookingDefaultFormProps = Readonly<{
+    booking: HeadlessBookingFlow;
+    onSubmit: () => Promise<void>;
+}>;
+export declare function HeadlessBookingDefaultForm({ booking, onSubmit, }: HeadlessBookingDefaultFormProps): React.ReactElement;
+export {};