@riverbankcms/sdk 0.121.0 → 0.124.0

package/dist/_dts/site-commands/src/domain.d.ts

@@ -1,6 +1,6 @@
 import type { Brand } from '../../core/src/index';
 import type { SiteCommandCapabilityGapCode } from './capabilityGaps';
-import type { SiteCommandType } from './commands';
+import type { SiteCommandType } from './commandContract';
 import type { SiteCommandRef } from './refs';
 export declare const commandScopes: readonly ["site", "style", "media", "page", "block", "navigation", "form", "footer", "content", "staff", "venue", "event_category", "event", "ticket", "course", "pass", "membership", "customer", "customer_pass", "customer_membership", "appointment", "course_enrollment", "event_registration", "pass_redemption", "order", "booking_settings", "appointment_service", "appointment_resource", "appointment_availability", "publish"];
 export type CommandScope = (typeof commandScopes)[number];

package/dist/_dts/site-commands/src/eventCommandContent.d.ts

@@ -0,0 +1,11 @@
+import type { SiteCommandOf } from './commandContract';
+type EventCommandContent = SiteCommandOf<'upsertEventSeries'>['input']['content'];
+export declare function mapEventCommandContent<TBody>(content: EventCommandContent, parseBody: (body: unknown) => TBody | undefined): {
+    image?: {
+        [x: string]: unknown;
+        identifier: string;
+    } | undefined;
+    body?: (TBody & ({} | null)) | undefined;
+    summary?: string | undefined;
+} | undefined;
+export {};

package/dist/_dts/site-commands/src/exposure.d.ts

@@ -1,4 +1,4 @@
-import type { SiteCommandBatch, SiteCommandType } from './commands';
+import type { SiteCommandBatch, SiteCommandType } from './commandContract';
 import type { AllowedRuntime, CommandRisk, IntendedExposure, SiteCommandCapabilityGap, SiteCommandMetadata } from './domain';
 import type { SiteCommandRef } from './refs';
 export type SiteCommandExposureTarget = Readonly<{

package/dist/_dts/site-commands/src/index.d.ts

@@ -1,12 +1,18 @@
 export * from './adapter';
 export * from './capabilityGaps';
+export * from './commandContract';
+export * from './commandDomain';
 export * from './commands';
 export * from './domain';
 export * from './exposure';
+export * from './eventCommandContent';
 export * from './metadata';
 export * from './pagePaths';
 export * from './planner';
 export * from './refContributions';
 export * from './refs';
+export * from './siteStyleCommandSchema';
+export * from './siteStyleSelectionSchemaBuilder';
 export * from './stableJson';
 export * from './staticExecutionGaps';
+export * from './venueCommandMapping';

package/dist/_dts/site-commands/src/metadata.d.ts

@@ -1,6 +1,6 @@
 import type { SiteCommandConsumerPolicy, SiteCommandMetadata, SiteCommandSemanticMetadata } from './domain';
 import type { LifecycleIntent } from './domain';
-import type { SiteCommand, SiteCommandType } from './commands';
+import type { SiteCommand, SiteCommandType } from './commandContract';
 export declare const siteCommandMetadata: {
     readonly configureSiteIdentity: {
         readonly scope: "site";
@@ -366,32 +366,6 @@ export declare const siteCommandMetadata: {
         readonly capability: "bookings.event_tickets.write";
         readonly support: "supported";
     };
-    readonly upsertCourse: {
-        readonly scope: "course";
-        readonly risk: "medium";
-        readonly writeSemantics: "upsert";
-        readonly lifecycleIntent: "mutation";
-        readonly idempotencyStrategy: "recipe_ref";
-        readonly conflictPolicy: "update_existing";
-        readonly previewability: "dry_run_only";
-        readonly allowedRuntimes: readonly ["development", "staging", "demo", "production"];
-        readonly intendedExposure: readonly ["recipe", "onboarding_planner", "internal_apply"];
-        readonly capability: "bookings.courses.write";
-        readonly support: "supported";
-    };
-    readonly deleteCourse: {
-        readonly scope: "course";
-        readonly risk: "medium";
-        readonly writeSemantics: "delete";
-        readonly lifecycleIntent: "mutation";
-        readonly idempotencyStrategy: "existing_id";
-        readonly conflictPolicy: "update_existing";
-        readonly previewability: "effect_required";
-        readonly allowedRuntimes: readonly ["development", "staging", "demo", "production"];
-        readonly intendedExposure: readonly ["sdk_cli", "internal_apply"];
-        readonly capability: "bookings.courses.delete";
-        readonly support: "supported";
-    };
     readonly upsertBookingPassProduct: {
         readonly scope: "pass";
         readonly risk: "medium";

package/dist/_dts/site-commands/src/planner.d.ts

@@ -1,5 +1,5 @@
 import { type Result } from '../../core/src/index';
-import { type SiteCommand, type SiteCommandBatch, type SiteCommandOf, type SiteCommandType } from './commands';
+import { type SiteCommand, type SiteCommandBatch, type SiteCommandOf, type SiteCommandType } from './commandContract';
 import { type CommandRisk, type LifecycleIntent, type SiteCommandCapabilityGap, type SiteCommandIdempotencyKey, type SiteCommandMetadata, type SiteCommandValidationError } from './domain';
 import { type ResourceRef } from './refs';
 type PlannedSiteCommandCommon = Readonly<{

package/dist/_dts/site-commands/src/refContributions.d.ts

@@ -1,4 +1,4 @@
-import type { SiteCommand } from './commands';
+import type { SiteCommand } from './commandContract';
 export type RefContribution = Readonly<{
     ref: string;
     field: string;

package/dist/_dts/site-commands/src/refs.d.ts

@@ -1,5 +1,5 @@
 import { type Brand, type Result } from '../../core/src/index';
-export declare const resourceKinds: readonly ["site-style", "media", "page", "block", "blocks", "nav", "form", "footer", "content", "staff", "venue", "event-category", "event", "course", "ticket", "pass", "membership", "customer", "customer-pass", "customer-membership", "appointment", "course-enrollment", "event-registration", "pass-redemption", "order", "appointment-service", "appointment-resource", "availability"];
+export declare const resourceKinds: readonly ["site-style", "media", "page", "block", "blocks", "nav", "form", "footer", "content", "staff", "venue", "event-category", "event", "ticket", "pass", "membership", "customer", "customer-pass", "customer-membership", "appointment", "course-enrollment", "event-registration", "pass-redemption", "order", "appointment-service", "appointment-resource", "availability"];
 export type ResourceKind = (typeof resourceKinds)[number];
 export type CommandRef = Brand<`${string}:${string}`, 'SiteCommandRef:command'>;
 export type SiteStyleRef = Brand<`site-style:${string}`, 'SiteCommandResourceRef:site-style'>;
@@ -15,7 +15,6 @@ export type StaffRef = Brand<`staff:${string}`, 'SiteCommandResourceRef:staff'>;
 export type VenueRef = Brand<`venue:${string}`, 'SiteCommandResourceRef:venue'>;
 export type EventCategoryRef = Brand<`event-category:${string}`, 'SiteCommandResourceRef:event-category'>;
 export type EventSeriesRef = Brand<`event:${string}`, 'SiteCommandResourceRef:event'>;
-export type CourseRef = Brand<`course:${string}`, 'SiteCommandResourceRef:course'>;
 export type TicketTypeRef = Brand<`ticket:${string}`, 'SiteCommandResourceRef:ticket'>;
 export type PassProductRef = Brand<`pass:${string}`, 'SiteCommandResourceRef:pass'>;
 export type MembershipProductRef = Brand<`membership:${string}`, 'SiteCommandResourceRef:membership'>;
@@ -45,7 +44,6 @@ export type ResourceRefByKind = Readonly<{
     venue: VenueRef;
     'event-category': EventCategoryRef;
     event: EventSeriesRef;
-    course: CourseRef;
     ticket: TicketTypeRef;
     pass: PassProductRef;
     membership: MembershipProductRef;
@@ -85,7 +83,6 @@ export declare function createFooterRef(parts: readonly string[]): FooterRef;
 export declare function createVenueRef(parts: readonly string[]): VenueRef;
 export declare function createEventCategoryRef(parts: readonly string[]): EventCategoryRef;
 export declare function createEventSeriesRef(parts: readonly string[]): EventSeriesRef;
-export declare function createCourseRef(parts: readonly string[]): CourseRef;
 export declare function createSiteCommandSiteRef(parts: readonly string[]): SiteCommandSiteRef;
 export declare function refSlug(ref: SiteCommandRef | string): string;
 export declare function parseResourceRef(value: string): Result<ResourceRef, RefParseError>;

package/dist/_dts/site-commands/src/siteStyleCommandSchema.d.ts

@@ -0,0 +1,378 @@
+import { z } from 'zod';
+import type { SiteStyleRef } from './refs';
+export declare const applySiteStyleSelectionCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"applySiteStyleSelection">;
+    ref: z.ZodPipe<z.ZodString, z.ZodTransform<SiteStyleRef, string>>;
+    input: z.ZodObject<{
+        changes: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"set-site-style">;
+            siteStyleId: z.ZodPipe<z.ZodString, z.ZodTransform<SiteStyleRef, string>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set-button-style">;
+            buttonStyleSelection: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                styleId: z.ZodLiteral<"soft-pill">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"earth-pill">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"confident-chip">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"editorial-link">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"pebble">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"ink-stamp">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"flat-ink">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"brushed-wash">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"showtime-pill">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"joy-stamp">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"ornate-ritual">;
+                parameters: z.ZodObject<{}, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                styleId: z.ZodLiteral<"quiet-arrow">;
+                parameters: z.ZodObject<{
+                    secondaryTreatment: z.ZodEnum<{
+                        outlined: "outlined";
+                        "solid-accent": "solid-accent";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>], "styleId">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set-palette">;
+            command: z.ZodType<import("../../blocks/src/index").PaletteCommand, unknown, z.core.$ZodTypeInternals<import("../../blocks/src/index").PaletteCommand, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set-typography">;
+            typography: z.ZodNullable<z.ZodObject<{
+                body: z.ZodObject<{
+                    family: z.ZodString;
+                    weight: z.ZodEnum<{
+                        medium: "medium";
+                        bold: "bold";
+                        light: "light";
+                        regular: "regular";
+                        semibold: "semibold";
+                    }>;
+                    letterSpacing: z.ZodEnum<{
+                        tight: "tight";
+                        normal: "normal";
+                        loose: "loose";
+                    }>;
+                    lineHeight: z.ZodEnum<{
+                        normal: "normal";
+                        loose: "loose";
+                        relaxed: "relaxed";
+                    }>;
+                    size: z.ZodEnum<{
+                        md: "md";
+                        lg: "lg";
+                        xl: "xl";
+                    }>;
+                }, z.core.$strip>;
+                headings: z.ZodObject<{
+                    default: z.ZodObject<{
+                        family: z.ZodString;
+                        weight: z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>;
+                        letterSpacing: z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>;
+                        lineHeight: z.ZodEnum<{
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                        }>;
+                        case: z.ZodNullable<z.ZodEnum<{
+                            uppercase: "uppercase";
+                            normal: "normal";
+                            smallCaps: "smallCaps";
+                        }>>;
+                        italic: z.ZodNullable<z.ZodBoolean>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>;
+                    h1: z.ZodObject<{
+                        weight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>>>;
+                        letterSpacing: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>>>;
+                        size: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            sm: "sm";
+                            md: "md";
+                            lg: "lg";
+                            xl: "xl";
+                            xs: "xs";
+                            "2xl": "2xl";
+                        }>>>;
+                        lineHeight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                            snug: "snug";
+                        }>>>;
+                        italic: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>;
+                    h2: z.ZodObject<{
+                        weight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>>>;
+                        letterSpacing: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>>>;
+                        size: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            sm: "sm";
+                            md: "md";
+                            lg: "lg";
+                            xl: "xl";
+                            xs: "xs";
+                            "2xl": "2xl";
+                        }>>>;
+                        lineHeight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                            snug: "snug";
+                        }>>>;
+                        italic: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>;
+                    h3: z.ZodObject<{
+                        weight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>>>;
+                        letterSpacing: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>>>;
+                        size: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            sm: "sm";
+                            md: "md";
+                            lg: "lg";
+                            xl: "xl";
+                            xs: "xs";
+                            "2xl": "2xl";
+                        }>>>;
+                        lineHeight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                            snug: "snug";
+                        }>>>;
+                        italic: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>;
+                    h4: z.ZodOptional<z.ZodObject<{
+                        weight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>>>;
+                        letterSpacing: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>>>;
+                        size: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            sm: "sm";
+                            md: "md";
+                            lg: "lg";
+                            xl: "xl";
+                            xs: "xs";
+                            "2xl": "2xl";
+                        }>>>;
+                        lineHeight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                            snug: "snug";
+                        }>>>;
+                        italic: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>;
+                    h5: z.ZodOptional<z.ZodObject<{
+                        weight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>>>;
+                        letterSpacing: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>>>;
+                        size: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            sm: "sm";
+                            md: "md";
+                            lg: "lg";
+                            xl: "xl";
+                            xs: "xs";
+                            "2xl": "2xl";
+                        }>>>;
+                        lineHeight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                            snug: "snug";
+                        }>>>;
+                        italic: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>;
+                    h6: z.ZodOptional<z.ZodObject<{
+                        weight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            medium: "medium";
+                            bold: "bold";
+                            light: "light";
+                            regular: "regular";
+                            semibold: "semibold";
+                        }>>>;
+                        letterSpacing: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                        }>>>;
+                        size: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            sm: "sm";
+                            md: "md";
+                            lg: "lg";
+                            xl: "xl";
+                            xs: "xs";
+                            "2xl": "2xl";
+                        }>>>;
+                        lineHeight: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                            tight: "tight";
+                            normal: "normal";
+                            loose: "loose";
+                            relaxed: "relaxed";
+                            snug: "snug";
+                        }>>>;
+                        italic: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                        colorToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+                scale: z.ZodEnum<{
+                    compact: "compact";
+                    spacious: "spacious";
+                    balanced: "balanced";
+                    minorThird: "minorThird";
+                    majorThird: "majorThird";
+                    perfectFourth: "perfectFourth";
+                }>;
+                proseLinkStyle: z.ZodOptional<z.ZodObject<{
+                    colorToken: z.ZodOptional<z.ZodString>;
+                    hoverColorToken: z.ZodOptional<z.ZodString>;
+                    underline: z.ZodOptional<z.ZodBoolean>;
+                    decorationColorToken: z.ZodOptional<z.ZodString>;
+                    hoverDecorationColorToken: z.ZodOptional<z.ZodString>;
+                    underlineStyle: z.ZodOptional<z.ZodEnum<{
+                        solid: "solid";
+                        dotted: "dotted";
+                        dashed: "dashed";
+                    }>>;
+                    underlineThickness: z.ZodOptional<z.ZodEnum<{
+                        auto: "auto";
+                        medium: "medium";
+                        fromFont: "fromFont";
+                        thin: "thin";
+                        thick: "thick";
+                    }>>;
+                    underlineOffset: z.ZodOptional<z.ZodEnum<{
+                        auto: "auto";
+                        tight: "tight";
+                        normal: "normal";
+                        loose: "loose";
+                    }>>;
+                }, z.core.$strip>>;
+                eyebrow: z.ZodOptional<z.ZodObject<{
+                    family: z.ZodString;
+                    size: z.ZodOptional<z.ZodEnum<{
+                        sm: "sm";
+                        md: "md";
+                        lg: "lg";
+                    }>>;
+                    weight: z.ZodOptional<z.ZodEnum<{
+                        medium: "medium";
+                        bold: "bold";
+                        light: "light";
+                        regular: "regular";
+                        semibold: "semibold";
+                    }>>;
+                    letterSpacing: z.ZodOptional<z.ZodEnum<{
+                        tight: "tight";
+                        normal: "normal";
+                        loose: "loose";
+                        wide: "wide";
+                    }>>;
+                    case: z.ZodOptional<z.ZodEnum<{
+                        uppercase: "uppercase";
+                        normal: "normal";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set-header">;
+            selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"default">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"legacy">;
+                headerLookId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"canonical">;
+                headerLookId: z.ZodNullable<z.ZodString>;
+                layoutId: z.ZodString;
+                styleId: z.ZodString;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"set-footer-look">;
+            footerLookId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>], "kind">>>;
+        baseSelectionVersion: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/_dts/site-commands/src/siteStyleSelectionSchemaBuilder.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+type SiteStyleSelectionSchemaParts<TSiteStyleId extends z.ZodType, TButtonStyleSelection extends z.ZodType, TPaletteCommand extends z.ZodType, TTypography extends z.ZodType, THeaderLookId extends z.ZodType, THeaderLayoutId extends z.ZodType, THeaderStyleId extends z.ZodType, TFooterLookId extends z.ZodType> = Readonly<{
+    siteStyleId: TSiteStyleId;
+    buttonStyleSelection: TButtonStyleSelection;
+    paletteCommand: TPaletteCommand;
+    typography: TTypography;
+    headerLookId: THeaderLookId;
+    headerLayoutId: THeaderLayoutId;
+    headerStyleId: THeaderStyleId;
+    footerLookId: TFooterLookId;
+}>;
+export declare function createSiteStyleSelectionChangeSchema<TSiteStyleId extends z.ZodType, TButtonStyleSelection extends z.ZodType, TPaletteCommand extends z.ZodType, TTypography extends z.ZodType, THeaderLookId extends z.ZodType, THeaderLayoutId extends z.ZodType, THeaderStyleId extends z.ZodType, TFooterLookId extends z.ZodType>(parts: SiteStyleSelectionSchemaParts<TSiteStyleId, TButtonStyleSelection, TPaletteCommand, TTypography, THeaderLookId, THeaderLayoutId, THeaderStyleId, TFooterLookId>): z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"set-site-style">;
+    siteStyleId: TSiteStyleId;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set-button-style">;
+    buttonStyleSelection: z.ZodNullable<TButtonStyleSelection>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set-palette">;
+    command: TPaletteCommand;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set-typography">;
+    typography: z.ZodNullable<TTypography>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set-header">;
+    selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"default">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"legacy">;
+        headerLookId: z.ZodNullable<THeaderLookId>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"canonical">;
+        headerLookId: z.ZodNullable<THeaderLookId>;
+        layoutId: THeaderLayoutId;
+        styleId: THeaderStyleId;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"set-footer-look">;
+    footerLookId: z.ZodNullable<TFooterLookId>;
+}, z.core.$strict>], "kind">;
+export declare function validateUniqueSiteStyleSelectionChanges(input: Readonly<{
+    changes: readonly Readonly<{
+        kind: string;
+    }>[];
+}>, ctx: z.RefinementCtx): void;
+export {};

package/dist/_dts/site-commands/src/staticExecutionGaps.d.ts

@@ -1,10 +1,10 @@
 import type { StaticExecutionGapCode } from './capabilityGaps';
-import type { SiteCommand, SiteCommandOf } from './commands';
+import type { SiteCommand, SiteCommandOf } from './commandContract';
 export type StaticExecutionGap = Readonly<{
     code: StaticExecutionGapCode;
     message: string;
 }>;
 export declare function staticExecutionGapsForCommand(command: SiteCommand): readonly StaticExecutionGap[];
 export declare function eventSeriesStaticExecutionGaps(command: SiteCommandOf<'upsertEventSeries'>): readonly StaticExecutionGap[];
+export declare function nativeWholeSeriesStaticExecutionGaps(command: SiteCommandOf<'upsertEventSeries'>): readonly StaticExecutionGap[];
 export declare function eventTicketTypeStaticExecutionGaps(command: SiteCommandOf<'upsertEventTicketType'>): readonly StaticExecutionGap[];
-export declare function courseStaticExecutionGaps(command: SiteCommandOf<'upsertCourse'>): readonly StaticExecutionGap[];

package/dist/_dts/site-commands/src/venueCommandMapping.d.ts

@@ -0,0 +1,21 @@
+import type { SiteCommandOf } from './commandContract';
+export declare function venueManagementFields(command: SiteCommandOf<'upsertVenue'>): {
+    slug: string;
+    title: string;
+    description: string | null;
+    timezone: string;
+    capacity: number | null;
+    address: {
+        line1: string | undefined;
+        line2: string | undefined;
+        city: string | undefined;
+        region: string | undefined;
+        postcode: string | undefined;
+        country: string | undefined;
+    } | undefined;
+    location: {
+        lat: number;
+        lng: number;
+    } | null;
+    mapEmbed: string | null;
+};

package/dist/_dts/theme-core/src/site-styles/compilationPlan.d.ts

@@ -0,0 +1,58 @@
+import type { Theme } from '../schema';
+import { type HeaderLayoutId, type HeaderLookId, type HeaderSelectionContext, type HeaderStyleId } from './headerLooks';
+import type { FooterLookId } from './footerLooks';
+import type { BrandDisplayMode, LogoSizePolicy } from './logoBranding';
+export type HeaderBrandPreferences = Readonly<{
+    brandDisplay: BrandDisplayMode;
+    logoSize: LogoSizePolicy;
+}>;
+export declare const defaultHeaderBrandPreferences: HeaderBrandPreferences;
+export declare function headerBrandPreferencesFromTheme(theme: Theme | null | undefined): HeaderBrandPreferences;
+export type HeaderSelectionIdentity = Readonly<{
+    headerLookId: HeaderLookId | null;
+    headerLayoutId: HeaderLayoutId | null;
+    headerStyleId: HeaderStyleId | null;
+}>;
+export type HeaderRecompileDirective = Readonly<{
+    kind: 'recompile';
+    selection: HeaderSelectionIdentity;
+    context: HeaderSelectionContext;
+    brandPresentation: ReplacementBrandPresentation;
+}>;
+export type HeaderCompilationDirective = Readonly<{
+    kind: 'preserve';
+    header: Theme['header'];
+    selection: HeaderSelectionIdentity;
+}> | HeaderRecompileDirective;
+export type FooterCompilationDirective = Readonly<{
+    kind: 'preserve';
+    footer: Theme['footer'];
+    footerLookId: FooterLookId | null;
+}> | Readonly<{
+    kind: 'apply-look';
+    footer: Theme['footer'];
+    footerLookId: FooterLookId | null;
+}>;
+export type ReplacementBrandPresentation = Readonly<{
+    kind: 'apply-logo-context';
+}> | Readonly<{
+    kind: 'use-compiled-defaults';
+}>;
+export type SiteThemeCompilationPlan = Readonly<{
+    kind: 'replace-site-style';
+    header: HeaderRecompileDirective;
+    footerLookId: FooterLookId | null;
+}> | Readonly<{
+    kind: 'update-selection';
+    header: HeaderCompilationDirective;
+    footer: FooterCompilationDirective;
+}>;
+export declare function replaceSiteStyleCompilationPlan(input?: Readonly<{
+    headerLookId?: HeaderLookId | null;
+    headerLayoutId?: HeaderLayoutId | null;
+    headerStyleId?: HeaderStyleId | null;
+    footerLookId?: FooterLookId | null;
+    headerSelectionContext?: Partial<HeaderSelectionContext>;
+}>): Extract<SiteThemeCompilationPlan, {
+    kind: 'replace-site-style';
+}>;