@riverbankcms/sdk 0.138.0 → 0.139.0

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

@@ -1,5 +1,6 @@
 import type { BillingInterval, BillingPlanId, PlanEntitlements } from '../plans/types';
-import type { SubscriptionRepository, SubscriptionRecord } from '../subscriptions/store';
+import { type SubscriptionRepository, type SubscriptionRecord } from '../subscriptions/store';
+import { type PlanStanding } from '../plans/standing';
 export interface MembershipState {
     userId: string;
     planId: BillingPlanId;
@@ -8,24 +9,30 @@ export interface MembershipState {
     currentPeriodEnd: string;
     cancelAtPeriodEnd: boolean;
     trialEndsAt?: string | null;
-    isPaid: boolean;
-    active: boolean;
     entitlements: PlanEntitlements;
 }
 export interface MembershipSummary {
     userId: string;
+    /** Effective entitlement plan. Provider subscription identity remains in the repository. */
     planId: BillingPlanId;
     interval: BillingInterval;
     status: SubscriptionRecord['status'];
     currentPeriodEnd: string;
     cancelAtPeriodEnd: boolean;
     trialEndsAt?: string | null;
-    isPaid: boolean;
-    active: boolean;
 }
+export type InvalidMembership = Readonly<{
+    kind: 'review_required';
+    userId: string;
+    reason: Extract<PlanStanding, {
+        kind: 'review_required';
+    }>['reason'];
+}>;
+export type MembershipRead = MembershipSummary | InvalidMembership | null;
+export declare function isMembershipReviewRequired(value: MembershipRead): value is InvalidMembership;
 export interface MembershipContext {
     subscriptions: SubscriptionRepository;
 }
 export declare function toMembershipSummary(state: MembershipState): MembershipSummary;
-export declare function getMembershipState(userId: string, context: MembershipContext): Promise<MembershipState | null>;
-export declare function getMembershipSummary(userId: string, context: MembershipContext): Promise<MembershipSummary | null>;
+export declare function getMembershipState(userId: string, context: MembershipContext): Promise<MembershipState | InvalidMembership | null>;
+export declare function getMembershipSummary(userId: string, context: MembershipContext): Promise<MembershipRead>;

package/dist/_dts/billing/src/plans/display.d.ts

@@ -0,0 +1,15 @@
+import { type BillingPlanId } from './types';
+/**
+ * What each plan is called in front of a customer.
+ *
+ * It lives apart from the registry because the registry reaches Stripe on
+ * import, and a name is the one thing a browser bundle needs. The registry
+ * reads its `name` fields from here, so there is still one source.
+ */
+export declare const BILLING_PLAN_NAMES: {
+    readonly free: "Free";
+    readonly core: "Core";
+    readonly solo: "Solo";
+    readonly studio: "Studio";
+};
+export declare function billingPlanName(planId: BillingPlanId): string;

package/dist/_dts/billing/src/plans/registry.d.ts

@@ -3,6 +3,8 @@ export declare function listPlans(): PlanDefinition[];
 export declare function isBillingPlanId(planId: string): planId is BillingPlanId;
 export declare function ensureBillingPlanId(planId: string): BillingPlanId;
 export declare function getPlanById(planId: string): PlanDefinition | undefined;
+/** Total lookup for a plan ID already validated at a trust boundary. */
+export declare function getKnownPlan(planId: BillingPlanId): PlanDefinition;
 export declare function ensurePlan(planId: string): PlanDefinition;
 export declare function getPlanEntitlements(planId: string): PlanDefinition['entitlements'];
 export declare function getMacadamiaSiteAllowance(planId: string): PlanDefinition['entitlements']['macadamiaSiteAllowance'];

package/dist/_dts/billing/src/plans/standing.d.ts

@@ -0,0 +1,19 @@
+import type { SubscriptionStandingEvidence, SubscriptionStandingEvidenceError, SubscriptionStandingInput } from '../subscriptions/standingEvidence';
+import { type SubscriptionRead } from '../subscriptions/store';
+type PaidStandingDetails = Pick<SubscriptionStandingEvidence, 'planId' | 'interval' | 'currentPeriodEnd' | 'cancelAtPeriodEnd'>;
+export type PlanStanding = Readonly<{
+    kind: 'paid';
+} & PaidStandingDetails> | Readonly<{
+    kind: 'payment_recovery';
+} & PaidStandingDetails> | Readonly<{
+    kind: 'free';
+    reason: 'no_subscription' | 'canceled' | 'unpaid' | 'incomplete' | 'incomplete_expired';
+}> | Readonly<{
+    kind: 'review_required';
+    reason: SubscriptionStandingEvidenceError | 'unsupported_subscription_status';
+}>;
+/** Stripe owns lifecycle timing. Period dates are display evidence, not a second expiry clock. */
+export declare function resolvePlanStanding(input: SubscriptionStandingInput): PlanStanding;
+/** Repository reads have already parsed provider evidence; never validate it again here. */
+export declare function resolveStoredPlanStanding(record: SubscriptionRead): PlanStanding;
+export {};

package/dist/_dts/billing/src/plans/types.d.ts

@@ -28,8 +28,6 @@ export declare const BILLING_PLAN_IDS: readonly ["free", "core", "solo", "studio
 export type BillingPlanId = (typeof BILLING_PLAN_IDS)[number];
 export declare const PAID_BILLING_PLAN_IDS: readonly ["core", "solo", "studio"];
 export type PaidBillingPlanId = (typeof PAID_BILLING_PLAN_IDS)[number];
-export declare const CONTENT_FLEXIBILITY_TIERS: readonly ["limited", "full"];
-export type ContentFlexibilityTier = (typeof CONTENT_FLEXIBILITY_TIERS)[number];
 export declare const FORMS_TIERS: readonly ["limited", "full"];
 export type FormsTier = (typeof FORMS_TIERS)[number];
 export declare const SEO_TIERS: readonly ["none", "basic", "advanced"];
@@ -62,7 +60,7 @@ export type WebsiteCollaborationPolicy = Readonly<{
     managementRoles: readonly ['owner', 'administrator'];
 }>;
 export type WebsiteCollaborationTier = WebsiteCollaborationPolicy['kind'];
-export declare const PLAN_BOOLEAN_FEATURE_KEYS: readonly ["customDomain", "customContentTypes", "analytics", "passes", "memberships", "discountCodes", "advancedPaymentSchemes", "internalNotes", "multiplePractitioners"];
+export declare const PLAN_BOOLEAN_FEATURE_KEYS: readonly ["customDomain", "analytics", "passes", "memberships", "discountCodes", "advancedPaymentSchemes", "multiplePractitioners"];
 export type PlanBooleanFeatureKey = (typeof PLAN_BOOLEAN_FEATURE_KEYS)[number];
 export type StripeBookingCommission = Readonly<{
     kind: 'none';
@@ -84,20 +82,16 @@ export interface PlanEntitlements {
             monthlyPricePence: number;
         }>;
     }>;
-    monthlyBookingLimit: number | null;
     durableStorageQuota: StorageQuota;
     stripeBookingCommission: StripeBookingCommission;
     customDomain: boolean;
-    customContentTypes: boolean;
     analytics: boolean;
     passes: boolean;
     memberships: boolean;
     discountCodes: boolean;
     advancedPaymentSchemes: boolean;
-    internalNotes: boolean;
     multiplePractitioners: boolean;
     websiteCollaboration: WebsiteCollaborationPolicy;
-    contentFlexibility: ContentFlexibilityTier;
     forms: FormsTier;
     seo: SeoTier;
     newsletter: NewsletterTier;

package/dist/_dts/billing/src/subscriptions/evidence.d.ts

@@ -0,0 +1,12 @@
+import type Stripe from 'stripe';
+import { type Result, type UtcIsoDateTimeString } from '../../../core/src/index';
+import type { PaidBillingPlanId } from '../plans/types';
+import type { SubscriptionRecord, SubscriptionStatus } from './store';
+export type SubscriptionEvidenceError = 'missing_identity' | 'invalid_plan' | 'invalid_interval' | 'invalid_status' | 'invalid_period_end' | 'invalid_cancellation' | 'invalid_trial_end';
+export type ProviderSubscriptionRecord = Omit<SubscriptionRecord, 'planId' | 'currentPeriodEnd'> & {
+    planId: PaidBillingPlanId;
+    currentPeriodEnd: UtcIsoDateTimeString;
+};
+export type SubscriptionEvidenceResult = Result<ProviderSubscriptionRecord, SubscriptionEvidenceError>;
+export declare function isSubscriptionStatus(value: unknown): value is SubscriptionStatus;
+export declare function parseProviderSubscription(subscription: Stripe.Subscription): SubscriptionEvidenceResult;

package/dist/_dts/billing/src/subscriptions/standingEvidence.d.ts

@@ -0,0 +1,31 @@
+import { type Result, type UtcIsoDateTimeString } from '../../../core/src/index';
+import type { BillingInterval, PaidBillingPlanId } from '../plans/types';
+import type { SubscriptionStatus } from './store';
+/** Untrusted stored columns, before defaults, casts or membership projection. */
+export type RawSubscriptionStandingEvidence = Readonly<{
+    planId: unknown;
+    interval: unknown;
+    status: unknown;
+    currentPeriodEnd: unknown;
+    cancelAtPeriodEnd: unknown;
+}>;
+export type SubscriptionStandingEvidenceError = 'invalid_plan' | 'invalid_interval' | 'invalid_status' | 'invalid_period_end' | 'invalid_cancellation';
+export type SubscriptionStandingEvidence = Readonly<{
+    planId: PaidBillingPlanId;
+    interval: BillingInterval;
+    status: SubscriptionStatus;
+    currentPeriodEnd: UtcIsoDateTimeString;
+    cancelAtPeriodEnd: boolean;
+}>;
+export type SubscriptionStandingInput = Readonly<{
+    kind: 'absent';
+}> | Readonly<{
+    kind: 'valid';
+    subscription: SubscriptionStandingEvidence;
+}> | Readonly<{
+    kind: 'invalid';
+    reason: SubscriptionStandingEvidenceError;
+}>;
+export declare function parseSubscriptionStandingEvidence(raw: RawSubscriptionStandingEvidence): Result<SubscriptionStandingEvidence, SubscriptionStandingEvidenceError>;
+/** Only a successful DB read with no row may supply null. Transport errors propagate. */
+export declare function readSubscriptionStandingInput(raw: RawSubscriptionStandingEvidence | null): SubscriptionStandingInput;

package/dist/_dts/billing/src/subscriptions/store.d.ts

@@ -1,6 +1,8 @@
+import type { ProviderSubscriptionRecord } from './evidence';
+import { type RawSubscriptionStandingEvidence, type SubscriptionStandingEvidenceError } from './standingEvidence';
 import type { BillingInterval } from '../plans/types';
 import type { BillingSubscriptionOrigin } from '../site-arrangements';
-export type SubscriptionStatus = 'incomplete' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid';
+export type SubscriptionStatus = 'incomplete_expired' | 'paused' | 'incomplete' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid';
 export interface SubscriptionRecord {
     id: string;
     userId: string;
@@ -14,17 +16,33 @@ export interface SubscriptionRecord {
     trialEnds_at?: string | null;
     raw?: Record<string, unknown>;
 }
+export type InvalidSubscriptionRecord = Readonly<{
+    kind: 'invalid';
+    id: string;
+    userId: string;
+    customerId: string;
+    reason: SubscriptionStandingEvidenceError;
+}>;
+export type SubscriptionRead = ProviderSubscriptionRecord | InvalidSubscriptionRecord | null;
+export declare function isInvalidSubscriptionRecord(value: SubscriptionRead): value is InvalidSubscriptionRecord;
+export declare class InvalidSubscriptionEvidenceError extends Error {
+    readonly evidence: InvalidSubscriptionRecord;
+    constructor(evidence: InvalidSubscriptionRecord);
+}
+/** For mutation boundaries that cannot operate without valid subscription evidence. */
+export declare function requireSubscriptionRecord(value: SubscriptionRead): ProviderSubscriptionRecord | null;
+export declare function readSubscriptionRecord(raw: Omit<SubscriptionRecord, keyof RawSubscriptionStandingEvidence> & RawSubscriptionStandingEvidence): ProviderSubscriptionRecord | InvalidSubscriptionRecord;
 export interface SubscriptionRepository {
     upsert(record: SubscriptionRecord): Promise<void>;
-    getByUserId(userId: string): Promise<SubscriptionRecord | null>;
-    getBySubscriptionId(subscriptionId: string): Promise<SubscriptionRecord | null>;
+    getByUserId(userId: string): Promise<SubscriptionRead>;
+    getBySubscriptionId(subscriptionId: string): Promise<SubscriptionRead>;
     removeBySubscriptionId(subscriptionId: string): Promise<void>;
 }
 export declare class InMemorySubscriptionRepository implements SubscriptionRepository {
     private byUser;
     private byId;
     upsert(record: SubscriptionRecord): Promise<void>;
-    getByUserId(userId: string): Promise<SubscriptionRecord | null>;
-    getBySubscriptionId(subscriptionId: string): Promise<SubscriptionRecord | null>;
+    getByUserId(userId: string): Promise<SubscriptionRead>;
+    getBySubscriptionId(subscriptionId: string): Promise<SubscriptionRead>;
     removeBySubscriptionId(subscriptionId: string): Promise<void>;
 }

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

@@ -1,12 +1,11 @@
 import * as React from 'react';
 import type { ResolverContext } from './system';
 import type { PageOutline } from './structure/schema';
-import type { Theme } from '../../theme-core/src/schema';
 import type { SdkCustomBlock } from './system/manifest/schema';
-import type { ThemeTokens } from './system/theme';
 import type { RouteMap } from './system/transforms';
+import { type OverrideOnlyRenderMode, type ThemedRenderMode, type TokensOnlyRenderMode } from './pageRenderingMode';
 import { type PageBoundaryWrapper, type PageRuntimeBoundary } from './pageRendererBoundaries';
-import type { BlockOverrides, PageRendererDataContext, SdkConfigForRenderer } from './pageRendererContracts';
+import { type BlockOverrides, type PageRendererDataContext, type SdkConfigForRenderer } from './pageRendererContracts';
 import { type RenderablePageOutline } from './pageRenderAdmission';
 export type { PageBlockRenderAdmissionError, RenderablePageBlock, RenderablePageOutline, } from './pageRenderAdmission';
 export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, OccurrenceContextData, SdkConfigForRenderer, } from './pageRendererContracts';
@@ -25,20 +24,12 @@ type PageRendererCommonProps<TPage> = {
     customBlocks?: SdkCustomBlock[];
     previewAuthoring?: ResolverContext['previewAuthoring'];
 };
-type ThemedPageRendererProps<TPage> = PageRendererCommonProps<TPage> & {
-    rendering?: never;
-    theme: Theme;
-    themeTokens?: ThemeTokens;
-};
-type OverrideOnlyPageRendererProps<TPage> = PageRendererCommonProps<TPage> & {
-    rendering: {
-        kind: 'overrides-only';
-    };
-    theme?: never;
-    themeTokens?: never;
+type ThemedPageRendererProps<TPage> = PageRendererCommonProps<TPage> & ThemedRenderMode;
+type TokensOnlyPageRendererProps<TPage> = PageRendererCommonProps<TPage> & TokensOnlyRenderMode;
+type OverrideOnlyPageRendererProps<TPage> = PageRendererCommonProps<TPage> & OverrideOnlyRenderMode & {
     blockOverrides: BlockOverrides;
 };
-export type PageRendererProps = ThemedPageRendererProps<RenderablePageOutline> | OverrideOnlyPageRendererProps<RenderablePageOutline>;
+export type PageRendererProps = ThemedPageRendererProps<RenderablePageOutline> | TokensOnlyPageRendererProps<RenderablePageOutline> | OverrideOnlyPageRendererProps<RenderablePageOutline>;
 export type EditorPageRendererProps = ThemedPageRendererProps<PageOutline> | OverrideOnlyPageRendererProps<PageOutline>;
 export default function PageRenderer(props: PageRendererProps): React.JSX.Element;
 export declare function EditorPageRenderer(props: EditorPageRendererProps): React.JSX.Element;

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

@@ -7,7 +7,7 @@
  *
  * For server-safe rendering, use './server'.
  */
-export { BlockApiProvider, useBlockApi, type BlockApiConfig, } from './system/runtime/api';
+export { BlockApiProvider, useBlockApi, type BlockApiClient, 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';

package/dist/_dts/blocks/src/contracts/proof-block-islands.d.ts

@@ -418,18 +418,22 @@ export declare const proofBlockIslandCodecs: {
             } & Readonly<{
                 display: Readonly<{
                     kind: "newsletter-form";
+                    availability: "ready" | "unavailable";
                     className: string | null;
                     buttonLabel: string;
                     buttonVariant: import("../system/runtime/nodes/newsletter-form.types").NewsletterButtonVariant;
-                    successMessage: string | null;
                     privacyNote: string | null;
                     fields: readonly import("../system/runtime/nodes/newsletter-form.types").NewsletterFieldDef[];
+                    choices: readonly Readonly<{
+                        id: string;
+                        label: string;
+                    }>[];
                 }>;
                 hydration: Readonly<{
                     target: import("../system/runtime/nodes/newsletter-form.interactive").NewsletterFormHydrationTarget;
-                    preset: import("../system/runtime/nodes/newsletter-form.types").NewsletterPreset;
-                    includePhone: boolean;
-                    tags?: string | null;
+                    setupRevision: number | null;
+                    choiceProvider: "native" | "brevo" | "mailchimp" | null;
+                    choicePresentation: "hidden" | "automatic" | "visitor_choice";
                     spamProtectionEnabled?: boolean;
                 }>;
             }>>;
@@ -444,18 +448,22 @@ export declare const proofBlockIslandCodecs: {
             } & Readonly<{
                 display: Readonly<{
                     kind: "newsletter-form";
+                    availability: "ready" | "unavailable";
                     className: string | null;
                     buttonLabel: string;
                     buttonVariant: import("../system/runtime/nodes/newsletter-form.types").NewsletterButtonVariant;
-                    successMessage: string | null;
                     privacyNote: string | null;
                     fields: readonly import("../system/runtime/nodes/newsletter-form.types").NewsletterFieldDef[];
+                    choices: readonly Readonly<{
+                        id: string;
+                        label: string;
+                    }>[];
                 }>;
                 hydration: Readonly<{
                     target: import("../system/runtime/nodes/newsletter-form.interactive").NewsletterFormHydrationTarget;
-                    preset: import("../system/runtime/nodes/newsletter-form.types").NewsletterPreset;
-                    includePhone: boolean;
-                    tags?: string | null;
+                    setupRevision: number | null;
+                    choiceProvider: "native" | "brevo" | "mailchimp" | null;
+                    choicePresentation: "hidden" | "automatic" | "visitor_choice";
                     spamProtectionEnabled?: boolean;
                 }>;
             }>>;
@@ -1340,18 +1348,22 @@ export declare const runtimeIslandCodecs: {
             } & Readonly<{
                 display: Readonly<{
                     kind: "newsletter-form";
+                    availability: "ready" | "unavailable";
                     className: string | null;
                     buttonLabel: string;
                     buttonVariant: import("../system/runtime/nodes/newsletter-form.types").NewsletterButtonVariant;
-                    successMessage: string | null;
                     privacyNote: string | null;
                     fields: readonly import("../system/runtime/nodes/newsletter-form.types").NewsletterFieldDef[];
+                    choices: readonly Readonly<{
+                        id: string;
+                        label: string;
+                    }>[];
                 }>;
                 hydration: Readonly<{
                     target: import("../system/runtime/nodes/newsletter-form.interactive").NewsletterFormHydrationTarget;
-                    preset: import("../system/runtime/nodes/newsletter-form.types").NewsletterPreset;
-                    includePhone: boolean;
-                    tags?: string | null;
+                    setupRevision: number | null;
+                    choiceProvider: "native" | "brevo" | "mailchimp" | null;
+                    choicePresentation: "hidden" | "automatic" | "visitor_choice";
                     spamProtectionEnabled?: boolean;
                 }>;
             }>>;
@@ -1366,18 +1378,22 @@ export declare const runtimeIslandCodecs: {
             } & Readonly<{
                 display: Readonly<{
                     kind: "newsletter-form";
+                    availability: "ready" | "unavailable";
                     className: string | null;
                     buttonLabel: string;
                     buttonVariant: import("../system/runtime/nodes/newsletter-form.types").NewsletterButtonVariant;
-                    successMessage: string | null;
                     privacyNote: string | null;
                     fields: readonly import("../system/runtime/nodes/newsletter-form.types").NewsletterFieldDef[];
+                    choices: readonly Readonly<{
+                        id: string;
+                        label: string;
+                    }>[];
                 }>;
                 hydration: Readonly<{
                     target: import("../system/runtime/nodes/newsletter-form.interactive").NewsletterFormHydrationTarget;
-                    preset: import("../system/runtime/nodes/newsletter-form.types").NewsletterPreset;
-                    includePhone: boolean;
-                    tags?: string | null;
+                    setupRevision: number | null;
+                    choiceProvider: "native" | "brevo" | "mailchimp" | null;
+                    choicePresentation: "hidden" | "automatic" | "visitor_choice";
                     spamProtectionEnabled?: boolean;
                 }>;
             }>>;

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

@@ -131,6 +131,8 @@ export type SdkConfigForRenderer = {
 export type PageRendererDataContext = {
     siteId?: string;
     pageId?: string;
+    /** Canonical request pathname used by blocks when resolving same-site destinations. */
+    pathname?: string;
     resolvedData?: Record<string, Record<string, unknown>>;
     previewStage?: 'published' | 'preview';
     previewToken?: string | null;
@@ -149,6 +151,8 @@ export type PageRendererDataContext = {
     apiBaseUrl?: string;
     portalToken?: string | null;
     bookingOfferingPresets?: readonly BookingOfferingPresetSummary[];
+    mailingList?: import('../../core/src/index').MailingListRuntimeContext;
     bookingTimeZone?: string;
     eventRegistrationOverlayEnabled?: boolean;
 };
+export declare function buildPageRendererRootRuntime(dataContext: PageRendererDataContext | undefined): Readonly<Record<string, unknown>>;

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

@@ -8,24 +8,31 @@ export declare class MissingBlockOverrideError extends Error {
 export type PageThemeResources = Readonly<{
     kind: 'available';
     tokens: ThemeTokens;
-    config: Theme;
+    config?: Theme;
 }> | Readonly<{
     kind: 'unavailable';
 }>;
-type ThemedResourceInput = Readonly<{
+export type ThemedRenderMode = Readonly<{
     rendering?: never;
     theme: Theme;
     themeTokens?: ThemeTokens;
 }>;
-type OverrideOnlyResourceInput = Readonly<{
+export type TokensOnlyRenderMode = Readonly<{
+    rendering: {
+        kind: 'tokens-only';
+    };
+    theme?: never;
+    themeTokens: ThemeTokens;
+}>;
+export type OverrideOnlyRenderMode = Readonly<{
     rendering: {
         kind: 'overrides-only';
     };
     theme?: never;
     themeTokens?: never;
 }>;
-type ThemeResourceInput = ThemedResourceInput | OverrideOnlyResourceInput;
-export declare function resolvePageThemeResources(props: ThemeResourceInput): PageThemeResources;
+export type PublicRenderMode = ThemedRenderMode | TokensOnlyRenderMode | OverrideOnlyRenderMode;
+export declare function resolvePageThemeResources(props: PublicRenderMode): PageThemeResources;
 export declare function requireBlockOverride(resources: PageThemeResources, override: unknown, blockKind: string): void;
 export declare function overrideThemeProps(resources: PageThemeResources): Readonly<{
     theme?: ThemeTokens;
@@ -34,4 +41,3 @@ export declare function overrideThemeProps(resources: PageThemeResources): Reado
 export declare function requireThemeResources(resources: PageThemeResources, blockKind: string): Extract<PageThemeResources, {
     kind: 'available';
 }>;
-export {};

package/dist/_dts/blocks/src/system/blocks/appointment-services.d.ts

@@ -0,0 +1,11 @@
+import type { SystemBlockDefinition } from '../registry';
+import { type SectionStylesContent } from '../fields/boxStyles';
+import type { BlockManifest } from '../manifest';
+declare const appointmentServicesManifest: BlockManifest;
+export type AppointmentServicesContent = Readonly<{
+    heading?: string | null;
+    description?: unknown;
+    _sectionStyles?: SectionStylesContent;
+}>;
+export declare const appointmentServicesBlockDefinition: SystemBlockDefinition<AppointmentServicesContent>;
+export { appointmentServicesManifest };

package/dist/_dts/blocks/src/system/blocks/contact-newsletter.d.ts

@@ -1,7 +1,7 @@
 import type { SystemBlockDefinition } from "../registry";
 import type { SectionStylesContent } from "../fields/boxStyles";
 import { type RichTextDoc } from "./form";
-import type { NewsletterSignupPreset } from "./newsletter-signup";
+import type { MailingListPlacementTargeting } from '../../../../core/src/index';
 export declare const contactNewsletterManifest: import("..").DefinedBlockManifest<import("..").BlockContentShapeInput<{
     readonly id: "block.contact-newsletter";
     readonly title: "Contact + Newsletter";
@@ -33,81 +33,58 @@ export declare const contactNewsletterManifest: import("..").DefinedBlockManifes
         readonly type: "richText";
         readonly label: "Newsletter intro";
     }, {
-        readonly id: "listId";
-        readonly type: "reference";
-        readonly label: "Newsletter list";
-        readonly description: "Select the list new subscribers should be added to.";
+        readonly id: "targeting";
+        readonly type: "group";
+        readonly label: "Mailing-list targeting";
+        readonly description: "Choose what kind of emails people signing up here will receive.";
         readonly required: true;
-        readonly referenceKind: "newsletterList";
-        readonly allowManualEntry: false;
+        readonly defaultValue: {
+            readonly mode: "default";
+        };
         readonly ui: {
             readonly intent: "behavior";
+            readonly widget: "mailingListTargeting";
         };
-    }, {
-        readonly id: "preset";
-        readonly type: "select";
-        readonly label: "Newsletter fields";
-        readonly defaultValue: "emailOnly";
-        readonly ui: {
-            readonly intent: "display";
+        readonly schema: {
+            readonly fields: [{
+                readonly id: "mode";
+                readonly type: "select";
+                readonly label: "Mode";
+                readonly required: true;
+                readonly defaultValue: "default";
+                readonly options: [{
+                    readonly value: "default";
+                    readonly label: "Default";
+                }, {
+                    readonly value: "custom";
+                    readonly label: "Custom";
+                }];
+                readonly ui: {
+                    readonly hidden: true;
+                };
+            }];
         };
-        readonly options: [{
-            readonly value: "emailOnly";
-            readonly label: "Email only";
-        }, {
-            readonly value: "emailName";
-            readonly label: "Email + Name";
-        }, {
-            readonly value: "emailFirstLast";
-            readonly label: "Email + First/Last Name";
-        }, {
-            readonly value: "emailNameCompany";
-            readonly label: "Email + Name + Company (B2B)";
-        }];
     }, {
-        readonly id: "includePhone";
-        readonly type: "boolean";
-        readonly label: "Include phone field";
-        readonly defaultValue: false;
-        readonly ui: {
-            readonly intent: "display";
-        };
-    }, {
-        readonly id: "newsletterButtonLabel";
+        readonly id: "contactTitle";
         readonly type: "text";
-        readonly label: "Newsletter button label";
-        readonly defaultValue: "Subscribe";
-        readonly ui: {
-            readonly intent: "display";
-        };
+        readonly label: "Contact title";
+        readonly defaultValue: "Get in touch";
     }, {
-        readonly id: "newsletterSuccessMessage";
+        readonly id: "mailingListSource";
         readonly type: "text";
-        readonly label: "Newsletter success message";
-        readonly defaultValue: "Thanks for subscribing!";
+        readonly label: "Mailing-list source";
         readonly ui: {
+            readonly hidden: true;
             readonly intent: "behavior";
         };
     }, {
-        readonly id: "newsletterPrivacyNote";
+        readonly id: "mailingListSourceToken";
         readonly type: "text";
-        readonly label: "Privacy note";
-        readonly ui: {
-            readonly intent: "display";
-        };
-    }, {
-        readonly id: "newsletterTags";
-        readonly type: "text";
-        readonly label: "Newsletter tags";
-        readonly description: "Optional tags to apply on subscribe, separated by comma or semicolon.";
+        readonly label: "Mailing-list source token";
         readonly ui: {
+            readonly hidden: true;
             readonly intent: "behavior";
         };
-    }, {
-        readonly id: "contactTitle";
-        readonly type: "text";
-        readonly label: "Contact title";
-        readonly defaultValue: "Get in touch";
     }, {
         readonly id: "contactIntro";
         readonly type: "richText";
@@ -157,13 +134,9 @@ export declare const contactNewsletterManifest: import("..").DefinedBlockManifes
 export type ContactNewsletterContent = {
     newsletterTitle?: string | null;
     newsletterSubtitle?: RichTextDoc | null;
-    listId?: string | null;
-    preset?: NewsletterSignupPreset;
-    includePhone?: boolean;
-    newsletterButtonLabel?: string | null;
-    newsletterSuccessMessage?: string | null;
-    newsletterPrivacyNote?: string | null;
-    newsletterTags?: string | null;
+    targeting: MailingListPlacementTargeting;
+    mailingListSource?: 'signed-footer' | null;
+    mailingListSourceToken?: string | null;
     contactTitle?: string | null;
     contactIntro?: RichTextDoc | null;
     formSlug: string;