@riverbankcms/sdk 0.138.0 → 0.140.0

package/dist/_dts/core/src/mailing-list-submission.d.ts

@@ -0,0 +1,224 @@
+import { type Brand, type ContentVersionId, type SiteId } from './branded';
+import type { FooterModuleId } from './footer-composition-types';
+import type { BrevoConfirmation, MailingListGlobalForm, MailingListProvider, MailingListSetupRevision, ToggleConfirmation } from './mailing-list-setup';
+import type { ResolvedMailingListTarget } from './mailing-list-targeting';
+import type { BrevoConnectionId, MailchimpConnectionId } from './mailing-list-identifiers';
+export declare const MAILING_LIST_SUBMISSION_BUDGET_MS = 10000;
+export type MailingListBlockId = Brand<string, 'MailingListBlockId'>;
+export type MailingListSignedSourceToken = Brand<string, 'MailingListSignedSourceToken'>;
+export type MailingListSdkFooterBlockId = Brand<string, 'MailingListSdkFooterBlockId'>;
+export type MailingListSdkContentHash = Brand<string, 'MailingListSdkContentHash'>;
+export type MailingListFooterRevision = Brand<number, 'MailingListFooterRevision'>;
+export type ExternalSignupConsentId = Brand<string, 'ExternalSignupConsentId'>;
+export type NormalizedSubscriberEmail = Brand<string, 'NormalizedSubscriberEmail'>;
+export declare function parseMailingListBlockId(value: unknown): MailingListBlockId | null;
+export declare function parseMailingListSignedSourceToken(value: unknown): MailingListSignedSourceToken | null;
+export declare function parseMailingListSdkFooterBlockId(value: unknown): MailingListSdkFooterBlockId | null;
+export declare function parseMailingListSdkContentHash(value: unknown): MailingListSdkContentHash | null;
+export declare function parseMailingListContentVersionId(value: unknown): ContentVersionId | null;
+export declare function parseMailingListFooterRevision(value: unknown): MailingListFooterRevision | null;
+export type MailingListSignupSource = Readonly<{
+    tag: 'published_block';
+    blockId: MailingListBlockId;
+    contentVersionId: ContentVersionId;
+}> | Readonly<{
+    tag: 'applied_footer';
+    sectionId: FooterModuleId;
+    revision: MailingListFooterRevision;
+}> | Readonly<{
+    tag: 'sdk_footer_block';
+    blockId: MailingListSdkFooterBlockId;
+    contentHash: MailingListSdkContentHash;
+}>;
+/** Public proof of which published placement owns a signup request. */
+export type MailingListSignupSourceRef = Readonly<{
+    tag: 'block_ref';
+    blockId: MailingListBlockId;
+    contentVersionId: ContentVersionId;
+}> | Readonly<{
+    tag: 'signed_source_ref';
+    token: MailingListSignedSourceToken;
+}>;
+/** Source identity signed into managed-footer and SDK-footer form tokens. */
+export type MailingListSignupTokenSource = Readonly<{
+    kind: 'footer-composition';
+    sectionId: FooterModuleId;
+    revision: MailingListFooterRevision;
+}> | Readonly<{
+    kind: 'sdk-footer-block';
+    blockId: MailingListSdkFooterBlockId;
+    contentHash: MailingListSdkContentHash;
+}>;
+export declare function buildMailingListSignupBlockSourceRef(blockId: unknown, contentVersionId: unknown): MailingListSignupSourceRef | null;
+type MailingListSignupProfileBase = Readonly<{
+    email: NormalizedSubscriberEmail;
+    phone: Readonly<{
+        tag: 'not_collected';
+    }> | Readonly<{
+        tag: 'collected';
+        value: string | null;
+    }>;
+}>;
+export type ResolvedMailingListProfileField = Readonly<{
+    requirement: 'required';
+    value: string;
+}> | Readonly<{
+    requirement: 'optional';
+    value: string | null;
+}>;
+export type MailingListSignupProfile = (MailingListSignupProfileBase & Readonly<{
+    preset: 'emailOnly';
+}>) | (MailingListSignupProfileBase & Readonly<{
+    preset: 'emailName';
+    name: ResolvedMailingListProfileField;
+}>) | (MailingListSignupProfileBase & Readonly<{
+    preset: 'emailFirstLast';
+    firstName: ResolvedMailingListProfileField;
+    lastName: ResolvedMailingListProfileField;
+}>) | (MailingListSignupProfileBase & Readonly<{
+    preset: 'emailNameCompany';
+    name: ResolvedMailingListProfileField;
+    company: ResolvedMailingListProfileField;
+}>);
+export type MailingListSignupProfileInput = Readonly<{
+    email: string;
+    name?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    company?: string | null;
+    phone?: string | null;
+}>;
+export type MailingListSignupProfileParseError = Readonly<{
+    tag: 'invalid_email';
+}> | Readonly<{
+    tag: 'required_field_missing';
+    field: 'name' | 'first_name' | 'last_name' | 'company';
+}>;
+export declare function parseMailingListSignupProfile(form: MailingListGlobalForm, input: MailingListSignupProfileInput): Readonly<{
+    ok: true;
+    value: MailingListSignupProfile;
+}> | Readonly<{
+    ok: false;
+    error: MailingListSignupProfileParseError;
+}>;
+type ResolvedMailingListSignupIntentBase = Readonly<{
+    siteId: SiteId;
+    setupRevision: MailingListSetupRevision;
+    source: MailingListSignupSource;
+    consentedAt: string;
+}>;
+type ResolvedMailingListProviderIntent = Readonly<{
+    provider: 'native';
+    target: Extract<ResolvedMailingListTarget, {
+        provider: 'native';
+    }>;
+    confirmation: ToggleConfirmation;
+}> | Readonly<{
+    provider: 'mailchimp';
+    connectionId: MailchimpConnectionId;
+    target: Extract<ResolvedMailingListTarget, {
+        provider: 'mailchimp';
+    }>;
+    confirmation: ToggleConfirmation;
+}> | Readonly<{
+    provider: 'brevo';
+    connectionId: BrevoConnectionId;
+    target: Extract<ResolvedMailingListTarget, {
+        provider: 'brevo';
+    }>;
+    confirmation: BrevoConfirmation;
+}>;
+export type ResolvedMailingListSignupIntent = ResolvedMailingListSignupIntentBase & Readonly<{
+    profile: MailingListSignupProfile;
+}> & ResolvedMailingListProviderIntent;
+export type MailingListProviderAcknowledgement = Readonly<{
+    tag: 'subscribed';
+}> | Readonly<{
+    tag: 'confirmation_requested';
+}>;
+export type MailingListProviderFailure = Readonly<{
+    tag: 'configuration_unavailable';
+}> | Readonly<{
+    tag: 'authentication_failed';
+}> | Readonly<{
+    tag: 'target_unavailable';
+}> | Readonly<{
+    tag: 'profile_rejected';
+}> | Readonly<{
+    tag: 'subscriber_suppressed';
+}> | Readonly<{
+    tag: 'rate_limited';
+}> | Readonly<{
+    tag: 'temporarily_unavailable';
+}> | Readonly<{
+    tag: 'uncertain';
+    reason: 'deadline_exceeded' | 'network_interrupted';
+}>;
+export type MailingListProviderSubmissionResult = Readonly<{
+    ok: true;
+    acknowledgement: MailingListProviderAcknowledgement;
+}> | Readonly<{
+    ok: false;
+    error: MailingListProviderFailure;
+}>;
+export type MailingListSubmissionDeadline = Readonly<{
+    deadlineEpochMs: number;
+    signal: AbortSignal;
+}>;
+export type MailingListProviderPort<TProvider extends MailingListProvider> = Readonly<{
+    submit: (intent: Extract<ResolvedMailingListSignupIntent, {
+        provider: TProvider;
+    }>, deadline: MailingListSubmissionDeadline) => Promise<MailingListProviderSubmissionResult>;
+}>;
+export type MailingListPublicSignupResponse = Readonly<{
+    tag: 'subscribed';
+}> | Readonly<{
+    tag: 'confirmation_required';
+}> | Readonly<{
+    tag: 'invalid_input';
+    reason: 'profile_rejected';
+}> | Readonly<{
+    tag: 'unavailable';
+    reason: 'configuration_unavailable' | 'stale_configuration' | 'authentication_failed' | 'target_unavailable' | 'rate_limited' | 'temporarily_unavailable';
+}> | Readonly<{
+    tag: 'uncertain';
+    reason: 'deadline_exceeded' | 'network_interrupted';
+}>;
+export declare function toMailingListPublicSignupResponse(result: MailingListProviderSubmissionResult): MailingListPublicSignupResponse;
+export type ExternalSignupConsentAttemptOutcome = Readonly<{
+    tag: 'consent_recorded';
+}> | Readonly<{
+    tag: 'provider_acknowledged';
+    acknowledgement: MailingListProviderAcknowledgement;
+}> | Readonly<{
+    tag: 'provider_failed';
+    failure: MailingListProviderFailure;
+}>;
+type ExternalSignupConsentRecordBase = Readonly<{
+    id: ExternalSignupConsentId;
+    siteId: SiteId;
+    normalizedEmail: NormalizedSubscriberEmail;
+    consentedAt: string;
+    source: MailingListSignupSource;
+    setupRevision: MailingListSetupRevision;
+    ipAddress: string | null;
+    userAgent: string | null;
+    referer: string | null;
+    outcome: ExternalSignupConsentAttemptOutcome;
+}>;
+export type ExternalSignupConsentRecord = (ExternalSignupConsentRecordBase & Readonly<{
+    provider: 'mailchimp';
+    connectionId: MailchimpConnectionId;
+    target: Extract<ResolvedMailingListTarget, {
+        provider: 'mailchimp';
+    }>;
+    confirmation: ToggleConfirmation;
+}>) | (ExternalSignupConsentRecordBase & Readonly<{
+    provider: 'brevo';
+    connectionId: BrevoConnectionId;
+    target: Extract<ResolvedMailingListTarget, {
+        provider: 'brevo';
+    }>;
+    confirmation: BrevoConfirmation;
+}>);
+export {};

package/dist/_dts/core/src/mailing-list-targeting-parser.d.ts

@@ -0,0 +1,12 @@
+import type { MailingListPlacementTargeting, MailingListVisitorSelection } from './mailing-list-targeting';
+import { type Result } from './result';
+export type MailingListTargetingParseError = Readonly<{
+    tag: 'invalid_mailing_list_targeting';
+    field: 'shape' | 'mode' | 'provider' | 'selection' | 'audienceId' | 'targets' | 'duplicate_target';
+}>;
+export type MailingListVisitorSelectionParseError = Readonly<{
+    tag: 'invalid_mailing_list_visitor_selection';
+    field: 'shape' | 'provider' | 'targets';
+}>;
+export declare function parseMailingListPlacementTargeting(value: unknown): Result<MailingListPlacementTargeting, MailingListTargetingParseError>;
+export declare function parseMailingListVisitorSelection(value: unknown): Result<MailingListVisitorSelection, MailingListVisitorSelectionParseError>;

package/dist/_dts/core/src/mailing-list-targeting.d.ts

@@ -0,0 +1,93 @@
+import type { ReadonlyNonEmptyArray } from './non-empty-array';
+import type { BrevoListId, MailchimpInterestId, MailchimpAudienceId } from './mailing-list-identifiers';
+import type { ConfiguredMailingListProvider, MailingListProvider, NativeMailingListTopicId } from './mailing-list-setup';
+import { type Result } from './result';
+export type MailingListDefaultTargeting = Readonly<{
+    mode: 'default';
+}>;
+export type NativeMailingListCustomTargeting = Readonly<{
+    mode: 'custom';
+    provider: 'native';
+    selection: Readonly<{
+        tag: 'fixed';
+        topicIds: ReadonlyNonEmptyArray<NativeMailingListTopicId>;
+    }> | Readonly<{
+        tag: 'visitor_choice';
+        offeredTopicIds: ReadonlyNonEmptyArray<NativeMailingListTopicId>;
+    }>;
+}>;
+export type BrevoMailingListCustomTargeting = Readonly<{
+    mode: 'custom';
+    provider: 'brevo';
+    selection: Readonly<{
+        tag: 'fixed';
+        listIds: ReadonlyNonEmptyArray<BrevoListId>;
+    }> | Readonly<{
+        tag: 'visitor_choice';
+        offeredListIds: ReadonlyNonEmptyArray<BrevoListId>;
+    }>;
+}>;
+export type MailchimpMailingListCustomTargeting = Readonly<{
+    mode: 'custom';
+    provider: 'mailchimp';
+    audienceId: MailchimpAudienceId;
+    selection: Readonly<{
+        tag: 'fixed';
+        interestIds: readonly MailchimpInterestId[];
+    }> | Readonly<{
+        tag: 'visitor_choice';
+        offeredInterestIds: ReadonlyNonEmptyArray<MailchimpInterestId>;
+    }>;
+}>;
+export type MailingListPlacementTargeting = MailingListDefaultTargeting | NativeMailingListCustomTargeting | BrevoMailingListCustomTargeting | MailchimpMailingListCustomTargeting;
+export declare function sameMailingListPlacementTargeting(left: MailingListPlacementTargeting, right: MailingListPlacementTargeting): boolean;
+export type MailingListVisitorSelection = Readonly<{
+    provider: 'native';
+    topicIds: readonly NativeMailingListTopicId[];
+}> | Readonly<{
+    provider: 'brevo';
+    listIds: readonly BrevoListId[];
+}> | Readonly<{
+    provider: 'mailchimp';
+    interestIds: readonly MailchimpInterestId[];
+}>;
+export type ResolvedMailingListTarget = Readonly<{
+    provider: 'native';
+    topicIds: ReadonlyNonEmptyArray<NativeMailingListTopicId>;
+}> | Readonly<{
+    provider: 'brevo';
+    listIds: ReadonlyNonEmptyArray<BrevoListId>;
+}> | Readonly<{
+    provider: 'mailchimp';
+    audienceId: MailchimpAudienceId;
+    interestIds: readonly MailchimpInterestId[];
+}>;
+export type MailingListTargetResolutionError = Readonly<{
+    tag: 'targeting_provider_mismatch';
+    setupProvider: MailingListProvider;
+    targetingProvider: MailingListProvider;
+}> | Readonly<{
+    tag: 'visitor_selection_not_allowed';
+}> | Readonly<{
+    tag: 'visitor_selection_required';
+}> | Readonly<{
+    tag: 'visitor_selection_provider_mismatch';
+}> | Readonly<{
+    tag: 'visitor_selection_outside_offer';
+}>;
+export declare function resolveMailingListTarget(input: Readonly<{
+    setup: ConfiguredMailingListProvider;
+    targeting: MailingListPlacementTargeting;
+    visitorSelection?: MailingListVisitorSelection;
+}>): Result<ResolvedMailingListTarget, MailingListTargetResolutionError>;
+export type MailingListChoicePresentation = Readonly<{
+    tag: 'hidden';
+}> | Readonly<{
+    tag: 'automatic';
+    selection: MailingListVisitorSelection;
+}> | Readonly<{
+    tag: 'visitor_choice';
+    provider: MailingListProvider;
+    optionCount: number;
+}>;
+export declare function planMailingListChoicePresentation(targeting: MailingListPlacementTargeting): MailingListChoicePresentation;

package/dist/_dts/core/src/navigation-locations.d.ts

@@ -0,0 +1,28 @@
+import { type Result } from './result';
+/** The only places a site's navigation can be displayed. */
+export declare const NAVIGATION_LOCATIONS: readonly ["main", "footer", "legal"];
+export type NavigationLocation = (typeof NAVIGATION_LOCATIONS)[number];
+export type NavigationLocationDescriptor = Readonly<{
+    location: NavigationLocation;
+    label: string;
+    description: string;
+}>;
+export declare const NAVIGATION_LOCATION_DESCRIPTORS: Readonly<Record<NavigationLocation, NavigationLocationDescriptor>>;
+export type SiteNavigationLocationRow<T = unknown> = Readonly<{
+    location: unknown;
+    value: T;
+}>;
+export type SiteNavigationLocationsError = Readonly<{
+    kind: 'invalid_location';
+    index: number;
+    value: unknown;
+}> | Readonly<{
+    kind: 'duplicate_location';
+    location: NavigationLocation;
+}> | Readonly<{
+    kind: 'missing_location';
+    location: NavigationLocation;
+}>;
+export type SiteNavigationLocations<T> = Readonly<Record<NavigationLocation, T>>;
+/** Parse all rows for one site into a complete fixed-location record. */
+export declare function parseSiteNavigationLocations<T>(rows: readonly SiteNavigationLocationRow<T>[]): Result<SiteNavigationLocations<T>, SiteNavigationLocationsError>;

package/dist/_dts/core/src/participants.d.ts

@@ -1,4 +1,4 @@
-import { type AppointmentId, type AttendeeId, type Brand, type CustomerId, type EventSeriesRegistrationId, type EventAttendeeGuestId, type ParticipantId } from './branded';
+import { type AppointmentId, type AttendeeId, type Brand, type CustomerId, type EventSeriesRegistrationId, type ParticipantId } from './branded';
 import { type Result } from './result';
 export type ParticipantEmail = Brand<string, 'ParticipantEmail'>;
 export type ParticipantSlotKey = Brand<string, 'ParticipantSlotKey'>;
@@ -14,26 +14,6 @@ export type ParticipantCountParseError = {
 } | {
     kind: 'non_positive_participant_count';
 };
-export type ProvisionalParticipantIdentity = Readonly<{
-    kind: 'event_guest';
-    eventAttendeeGuestId: EventAttendeeGuestId;
-    slotKey: ParticipantSlotKey;
-}>;
-export type ProvisionalParticipantIdentityMetadata = Readonly<{
-    kind: 'event_guest';
-    source: 'event_guest_backfill';
-    eventAttendeeGuestId: EventAttendeeGuestId;
-    slotKey: ParticipantSlotKey;
-}>;
-export type ProvisionalParticipantIdentityParseError = {
-    kind: 'not_an_object';
-} | {
-    kind: 'unsupported_identity_kind';
-} | {
-    kind: 'missing_event_attendee_guest_id';
-} | {
-    kind: 'missing_slot_key';
-};
 export declare function unsafeAsParticipantSlotKey(value: string): ParticipantSlotKey;
 export declare function unsafeAsParticipantCount(value: number): ParticipantCount;
 /**
@@ -45,12 +25,6 @@ export declare function unsafeAsParticipantCount(value: number): ParticipantCoun
 export declare function normalizeParticipantEmail(value: string | null | undefined): ParticipantEmail | null;
 export declare function parseParticipantEmail(value: string | null | undefined): Result<ParticipantEmail, ParticipantEmailNormalizationError>;
 export declare function parseParticipantCount(value: number): Result<ParticipantCount, ParticipantCountParseError>;
-export declare function provisionalEventGuestParticipantIdentity(input: Readonly<{
-    eventAttendeeGuestId: EventAttendeeGuestId;
-    slotKey: ParticipantSlotKey;
-}>): ProvisionalParticipantIdentity;
-export declare function encodeProvisionalParticipantIdentity(identity: ProvisionalParticipantIdentity): ProvisionalParticipantIdentityMetadata;
-export declare function parseProvisionalParticipantIdentity(value: unknown): Result<ProvisionalParticipantIdentity, ProvisionalParticipantIdentityParseError>;
 export declare function deriveParticipantDisplayLabel(input: Readonly<{
     displayName: string | null;
     emailNormalized: ParticipantEmail | null;
@@ -100,7 +74,7 @@ export type ParticipantParticipation = {
 } | {
     kind: 'event_guest';
     attendeeId: AttendeeId;
-    guestId: EventAttendeeGuestId;
+    guestIndex: number;
 } | {
     kind: 'event_series_registration';
     registrationId: EventSeriesRegistrationId;
@@ -177,7 +151,6 @@ export type EventRegistrationParticipantProjectionInput = Readonly<{
         customerId: CustomerId;
     };
     guests: readonly (ParticipantContactInput & {
-        guestId: EventAttendeeGuestId;
         guestIndex: number;
     })[];
 }>;

package/dist/_dts/core/src/public-experience.d.ts

@@ -0,0 +1,4 @@
+export declare const PUBLIC_EXPERIENCES: readonly ["website", "hosted_booking"];
+export type PublicExperience = (typeof PUBLIC_EXPERIENCES)[number];
+export declare function isPublicExperience(value: unknown): value is PublicExperience;
+export declare function parsePublicExperience(value: unknown): PublicExperience | null;

package/dist/_dts/core/src/public-profile.d.ts

@@ -55,13 +55,42 @@ export type PublicSocialLink = Readonly<{
     label: string;
     url: string;
 }>;
+/**
+ * Whether the site shows its business address publicly. Absent on every
+ * profile saved before this field existed, and the footer has always shown
+ * the address whenever its composition selected one, so absent reads as
+ * `shown`.
+ */
+export type PublicAddressVisibility = 'shown' | 'hidden';
+/**
+ * Whether each contact method is published on the site. Both default to shown,
+ * because that is what a saved contact has always meant. A hidden email can
+ * still be the privacy policy's contact: hiding it withholds it from the page,
+ * not from the policy.
+ */
+export type PublicContactVisibility = Readonly<{
+    phone: PublicAddressVisibility;
+    email: PublicAddressVisibility;
+}>;
 export type PublicProfile = Readonly<{
     contact: PublicContactDetails | null;
+    contactVisibility: PublicContactVisibility;
     openingHours: WeeklyOpeningHours | null;
     socialLinks: readonly PublicSocialLink[];
+    addressVisibility: PublicAddressVisibility;
+    /**
+     * Whether the business runs from a place people come to, which is what the
+     * address and opening hours belong to.
+     *
+     * Null means nobody has answered yet, and it stays null rather than
+     * defaulting to false: a site that already has a saved address plainly has
+     * premises, and only the caller holding that address can say so. Resolve it
+     * with `resolvePublicProfilePremises`.
+     */
+    premises: boolean | null;
 }>;
 export type PublicProfileParseError = Readonly<{
-    code: 'invalid_shape' | 'contact_method_required' | 'invalid_email' | 'invalid_phone' | 'invalid_timezone' | 'invalid_weekdays' | 'invalid_time' | 'invalid_interval' | 'overlapping_intervals' | 'invalid_social_link' | 'duplicate_social_link_id';
+    code: 'invalid_shape' | 'contact_method_required' | 'invalid_email' | 'invalid_phone' | 'invalid_timezone' | 'invalid_weekdays' | 'invalid_time' | 'invalid_interval' | 'overlapping_intervals' | 'invalid_social_link' | 'invalid_address_visibility' | 'invalid_contact_visibility' | 'invalid_premises' | 'duplicate_social_link_id';
     path: string;
     message: string;
 }>;
@@ -70,4 +99,9 @@ export declare function parsePublicProfileTimeZone(value: unknown): Result<Publi
 export declare function parseWeeklyOpeningHours(value: unknown): Result<WeeklyOpeningHours, PublicProfileParseError>;
 export declare function parsePublicSocialLinks(value: unknown): Result<readonly PublicSocialLink[], PublicProfileParseError>;
 export declare function parsePublicProfile(value: unknown): Result<PublicProfile, PublicProfileParseError>;
+/**
+ * Resolves whether a site has premises, falling back to whether it already
+ * holds a business address for every profile saved before the switch existed.
+ */
+export declare function resolvePublicProfilePremises(profile: PublicProfile, hasBusinessAddress: boolean): boolean;
 export declare function emptyPublicProfile(): PublicProfile;

package/dist/_dts/core/src/public-read-cache-contract.d.ts

@@ -0,0 +1,45 @@
+export type PublicReadEndpoint = 'listPublishedEntries' | 'getPublishedEntryPreview' | 'listPublicEvents' | 'listPublicEventCalendarWindow' | 'listPublicRecurringSchedule' | 'getPublicEventDetails' | 'resolveEventSubroute' | 'listPublicRouteCandidates' | 'listPublicTeamMembers' | 'listPublicProducts' | 'listPublicPasses' | 'listPublicMemberships' | 'getPublicFormById' | 'getPublicBookingServices' | 'getPublicBookingService' | 'getPublicBookingResourcesReference' | 'getPublicBookingAvailableDates' | 'getPublicBookingAvailableSlots' | 'getPublicWeeklySlotAvailability' | 'listPublicForms' | 'checkRedirect' | 'getPublicRoutableContent' | 'getPublicSitemapRoutes';
+export type PublicReadCacheTagKind = 'published_content' | 'public_team_members' | 'public_products' | 'site_forms';
+export type PublicReadTransport = 'direct' | 'batch_only';
+export type PublicReadCachePolicy = Readonly<{
+    kind: 'live';
+    reason: 'booking_correctness';
+    freshness: 'availability';
+    transport: PublicReadTransport;
+}> | Readonly<{
+    kind: 'tagged';
+    tags: readonly PublicReadCacheTagKind[];
+    freshness: 'content';
+    transport: PublicReadTransport;
+}>;
+export declare const PUBLIC_AVAILABILITY_FRESHNESS_SECONDS = 60;
+export declare const PUBLIC_CONTENT_FRESHNESS_SECONDS = 3600;
+/** The single classification authority for cacheable public reads. */
+export declare const PUBLIC_READ_CACHE_POLICIES: {
+    readonly listPublishedEntries: PublicReadCachePolicy;
+    readonly getPublishedEntryPreview: PublicReadCachePolicy;
+    readonly listPublicEvents: PublicReadCachePolicy;
+    readonly listPublicEventCalendarWindow: PublicReadCachePolicy;
+    readonly listPublicRecurringSchedule: PublicReadCachePolicy;
+    readonly getPublicEventDetails: PublicReadCachePolicy;
+    readonly resolveEventSubroute: PublicReadCachePolicy;
+    readonly listPublicRouteCandidates: PublicReadCachePolicy;
+    readonly listPublicTeamMembers: PublicReadCachePolicy;
+    readonly listPublicProducts: PublicReadCachePolicy;
+    readonly listPublicPasses: PublicReadCachePolicy;
+    readonly listPublicMemberships: PublicReadCachePolicy;
+    readonly getPublicFormById: PublicReadCachePolicy;
+    readonly getPublicBookingServices: PublicReadCachePolicy;
+    readonly getPublicBookingService: PublicReadCachePolicy;
+    readonly getPublicBookingResourcesReference: PublicReadCachePolicy;
+    readonly getPublicBookingAvailableDates: PublicReadCachePolicy;
+    readonly getPublicBookingAvailableSlots: PublicReadCachePolicy;
+    readonly getPublicWeeklySlotAvailability: PublicReadCachePolicy;
+    readonly listPublicForms: PublicReadCachePolicy;
+    readonly checkRedirect: PublicReadCachePolicy;
+    readonly getPublicRoutableContent: PublicReadCachePolicy;
+    readonly getPublicSitemapRoutes: PublicReadCachePolicy;
+};
+export declare function isPublicReadEndpoint(endpoint: string): endpoint is PublicReadEndpoint;
+export declare function getPublicReadCachePolicy(endpoint: PublicReadEndpoint): PublicReadCachePolicy;
+export declare function publicReadFreshnessSeconds(endpoint: PublicReadEndpoint): number;

package/dist/_dts/core/src/site-route-target.d.ts

@@ -1,6 +1,6 @@
-import { type BrandedIdParseError, type ContentEntryId, type PageId, type PageSurfaceId } from './branded';
+import { type BrandedIdParseError, type ContentEntryId, type AppointmentServiceId, type PageId, type PageSurfaceId } from './branded';
 import { type Result } from './result';
-export declare const SITE_ROUTE_NODE_TYPES: readonly ["page", "content_entry", "page_surface"];
+export declare const SITE_ROUTE_NODE_TYPES: readonly ["page", "content_entry", "page_surface", "appointment_service"];
 export type SiteRouteNodeType = (typeof SITE_ROUTE_NODE_TYPES)[number];
 export type SiteRouteTarget = Readonly<{
     kind: 'page';
@@ -11,6 +11,9 @@ export type SiteRouteTarget = Readonly<{
 }> | Readonly<{
     kind: 'pageSurface';
     surfaceId: PageSurfaceId;
+}> | Readonly<{
+    kind: 'appointmentService';
+    serviceId: AppointmentServiceId;
 }>;
 export type SiteRouteTargetParseError = Readonly<{
     kind: 'invalid-node-type';
@@ -27,6 +30,9 @@ export type SiteRouteTargetParseError = Readonly<{
 }> | Readonly<{
     kind: 'invalid-page-surface-id';
     error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalid-appointment-service-id';
+    error: BrandedIdParseError;
 }>;
 export declare function parseSiteRouteTarget(input: Readonly<{
     nodeType: unknown;
@@ -37,4 +43,5 @@ export declare function foldSiteRouteTarget<TValue>(target: SiteRouteTarget, cas
     page: (pageId: PageId) => TValue;
     contentEntry: (entryId: ContentEntryId) => TValue;
     pageSurface: (surfaceId: PageSurfaceId) => TValue;
+    appointmentService: (serviceId: AppointmentServiceId) => TValue;
 }>): TValue;