@riverbankcms/sdk 0.2.0 → 0.2.1

package/dist/server/types-C0G9IxWO.d.mts

@@ -0,0 +1,4149 @@
+import { AIChatMessage } from '@riverbankcms/ai';
+import { S as SdkCustomBlock } from './schema-Bpy9N5ZI.mjs';
+import { z } from 'zod';
+import { ListMediaAssetsResult, MediaAssetWithLabels } from '@riverbankcms/media-storage-supabase';
+import { ImpersonationScope, DbRow, CamelizeKeys, DbJson, DbDatabase } from '@riverbankcms/db';
+
+type BillingInterval = 'monthly' | 'annual';
+type FeatureKey = 'sites.multiple' | 'ai.workflows' | 'support.priority' | 'themes.advanced' | 'limits.highUsage' | 'collaboration.admin' | 'collaboration.editor';
+
+type SubscriptionStatus = 'incomplete' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid';
+interface SubscriptionRecord {
+    id: string;
+    userId: string;
+    customerId: string;
+    planId: string;
+    interval: BillingInterval;
+    status: SubscriptionStatus;
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    trialEnds_at?: string | null;
+    raw?: Record<string, unknown>;
+}
+
+interface MembershipState {
+    userId: string;
+    planId: string;
+    interval: BillingInterval;
+    status: SubscriptionRecord['status'];
+    currentPeriodEnd: string;
+    cancelAtPeriodEnd: boolean;
+    trialEndsAt?: string | null;
+    isPaid: boolean;
+    active: boolean;
+    capabilities: FeatureKey[];
+}
+
+type ExpandedPalette = {
+    meta: PaletteMeta;
+    [token: string]: any;
+};
+
+declare const paletteMetaSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        dark: "dark";
+        light: "light";
+    }>;
+}, z.core.$strip>;
+declare const themeSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    rationale: z.ZodString;
+    axes: z.ZodObject<{
+        tone: z.ZodEnum<{
+            bold: "bold";
+            classic: "classic";
+            minimal: "minimal";
+        }>;
+        energy: z.ZodEnum<{
+            calm: "calm";
+            vibrant: "vibrant";
+        }>;
+        density: z.ZodEnum<{
+            compact: "compact";
+            airy: "airy";
+            regular: "regular";
+        }>;
+        mediaBias: z.ZodEnum<{
+            text: "text";
+            media: "media";
+            mixed: "mixed";
+        }>;
+        conversionBias: z.ZodEnum<{
+            low: "low";
+            high: "high";
+            med: "med";
+        }>;
+        motion: z.ZodEnum<{
+            subtle: "subtle";
+            standard: "standard";
+            expressive: "expressive";
+        }>;
+    }, z.core.$strip>;
+    palette: z.ZodObject<{
+        colors: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            hex: z.ZodString;
+        }, z.core.$strip>>;
+        meta: z.ZodObject<{
+            mode: z.ZodEnum<{
+                dark: "dark";
+                light: "light";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    typography: z.ZodObject<{
+        body: z.ZodObject<{
+            family: z.ZodString;
+            weight: z.ZodEnum<{
+                bold: "bold";
+                medium: "medium";
+                light: "light";
+                regular: "regular";
+                semibold: "semibold";
+            }>;
+            letterSpacing: z.ZodEnum<{
+                normal: "normal";
+                loose: "loose";
+                tight: "tight";
+            }>;
+            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<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>;
+                letterSpacing: z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>;
+                lineHeight: z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>;
+                case: z.ZodNullable<z.ZodEnum<{
+                    uppercase: "uppercase";
+                    normal: "normal";
+                    smallCaps: "smallCaps";
+                }>>;
+            }, z.core.$strip>;
+            h1: z.ZodObject<{
+                weight: z.ZodNullable<z.ZodEnum<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>>;
+                letterSpacing: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                lineHeight: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>>;
+            }, z.core.$strip>;
+            h2: z.ZodObject<{
+                weight: z.ZodNullable<z.ZodEnum<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>>;
+                letterSpacing: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                lineHeight: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>>;
+            }, z.core.$strip>;
+            h3: z.ZodObject<{
+                weight: z.ZodNullable<z.ZodEnum<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>>;
+                letterSpacing: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                lineHeight: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>>;
+            }, z.core.$strip>;
+            h4: z.ZodOptional<z.ZodObject<{
+                weight: z.ZodNullable<z.ZodEnum<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>>;
+                letterSpacing: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                lineHeight: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>>;
+            }, z.core.$strip>>;
+            h5: z.ZodOptional<z.ZodObject<{
+                weight: z.ZodNullable<z.ZodEnum<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>>;
+                letterSpacing: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                lineHeight: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>>;
+            }, z.core.$strip>>;
+            h6: z.ZodOptional<z.ZodObject<{
+                weight: z.ZodNullable<z.ZodEnum<{
+                    bold: "bold";
+                    medium: "medium";
+                    light: "light";
+                    regular: "regular";
+                    semibold: "semibold";
+                }>>;
+                letterSpacing: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    tight: "tight";
+                }>>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                lineHeight: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    loose: "loose";
+                    relaxed: "relaxed";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        scale: z.ZodEnum<{
+            minorThird: "minorThird";
+            majorThird: "majorThird";
+            perfectFourth: "perfectFourth";
+        }>;
+    }, z.core.$strip>;
+    space: z.ZodEnum<{
+        dense: "dense";
+        comfortable: "comfortable";
+        standard: "standard";
+    }>;
+    border: z.ZodObject<{
+        width: z.ZodEnum<{
+            none: "none";
+            thick: "thick";
+            thin: "thin";
+            hairline: "hairline";
+        }>;
+        style: z.ZodEnum<{
+            dashed: "dashed";
+            solid: "solid";
+        }>;
+    }, z.core.$strip>;
+    shadow: z.ZodObject<{
+        elevation: z.ZodEnum<{
+            none: "none";
+            medium: "medium";
+            low: "low";
+            high: "high";
+        }>;
+        softness: z.ZodNullable<z.ZodEnum<{
+            soft: "soft";
+            crisp: "crisp";
+            hard: "hard";
+        }>>;
+        position: z.ZodDefault<z.ZodEnum<{
+            bottom: "bottom";
+            "bottom-right": "bottom-right";
+        }>>;
+    }, z.core.$strip>;
+    motion: z.ZodObject<{
+        level: z.ZodEnum<{
+            medium: "medium";
+            low: "low";
+            high: "high";
+            off: "off";
+        }>;
+        easing: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            snappy: "snappy";
+            gentle: "gentle";
+        }>>;
+    }, z.core.$strip>;
+    corners: z.ZodEnum<{
+        square: "square";
+        rounded: "rounded";
+        pill: "pill";
+        soft: "soft";
+    }>;
+    gradients: z.ZodOptional<z.ZodObject<{
+        button: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        hero: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        background: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    header: z.ZodObject<{
+        variant: z.ZodEnum<{
+            transparent: "transparent";
+            classic: "classic";
+            centered: "centered";
+            floating: "floating";
+            editorial: "editorial";
+        }>;
+        positioning: z.ZodEnum<{
+            fixed: "fixed";
+            static: "static";
+            sticky: "sticky";
+        }>;
+        shrinkOnScroll: z.ZodBoolean;
+        maxWidth: z.ZodEnum<{
+            full: "full";
+            container: "container";
+        }>;
+        logoOverride: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                video: "video";
+            }>;
+            purpose: z.ZodOptional<z.ZodString>;
+            placeholder: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            assetId: z.ZodOptional<z.ZodString>;
+            src: z.ZodOptional<z.ZodString>;
+            alt: z.ZodOptional<z.ZodString>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            storageBucket: z.ZodOptional<z.ZodString>;
+            storagePath: z.ZodOptional<z.ZodString>;
+            transform: z.ZodOptional<z.ZodObject<{
+                rect: z.ZodOptional<z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+                hotspot: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    radius: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        background: z.ZodDefault<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                color: "color";
+                gradient: "gradient";
+            }>;
+            color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            gradient: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    linear: "linear";
+                    radial: "radial";
+                }>;
+                angle: z.ZodOptional<z.ZodNumber>;
+                position: z.ZodOptional<z.ZodString>;
+                stops: z.ZodArray<z.ZodObject<{
+                    color: z.ZodString;
+                    position: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            image: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    image: "image";
+                    video: "video";
+                }>;
+                purpose: z.ZodOptional<z.ZodString>;
+                placeholder: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                assetId: z.ZodOptional<z.ZodString>;
+                src: z.ZodOptional<z.ZodString>;
+                alt: z.ZodOptional<z.ZodString>;
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                storageBucket: z.ZodOptional<z.ZodString>;
+                storagePath: z.ZodOptional<z.ZodString>;
+                transform: z.ZodOptional<z.ZodObject<{
+                    rect: z.ZodOptional<z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+                    hotspot: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        radius: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            textColor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        navStyle: z.ZodEnum<{
+            solid: "solid";
+            underline: "underline";
+            scale: "scale";
+            minimal: "minimal";
+            "underline-grow": "underline-grow";
+            capsule: "capsule";
+            frosted: "frosted";
+        }>;
+        navColor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        navWeight: z.ZodDefault<z.ZodEnum<{
+            bold: "bold";
+            medium: "medium";
+            regular: "regular";
+            semibold: "semibold";
+        }>>;
+        container: z.ZodOptional<z.ZodObject<{
+            rounded: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+                xl: "xl";
+                "2xl": "2xl";
+            }>>;
+            border: z.ZodDefault<z.ZodBoolean>;
+            shadow: z.ZodDefault<z.ZodBoolean>;
+            padding: z.ZodDefault<z.ZodEnum<{
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+            }>>;
+            tint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        border: z.ZodOptional<z.ZodObject<{
+            width: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                medium: "medium";
+                thick: "thick";
+                thin: "thin";
+            }>>;
+            style: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                dashed: "dashed";
+                solid: "solid";
+            }>>;
+            position: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                top: "top";
+                both: "both";
+                bottom: "bottom";
+            }>>;
+            color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+        logo: z.ZodOptional<z.ZodObject<{
+            fontFamily: z.ZodDefault<z.ZodEnum<{
+                inherit: "inherit";
+                serif: "serif";
+                mono: "mono";
+            }>>;
+            letterSpacing: z.ZodDefault<z.ZodEnum<{
+                normal: "normal";
+                wide: "wide";
+                wider: "wider";
+                widest: "widest";
+            }>>;
+            gradient: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        navEffects: z.ZodOptional<z.ZodObject<{
+            underlineGradient: z.ZodDefault<z.ZodBoolean>;
+            glow: z.ZodDefault<z.ZodBoolean>;
+            glowColor: z.ZodOptional<z.ZodString>;
+            neumorphic: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        navContainer: z.ZodDefault<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                pill: "pill";
+                glass: "glass";
+            }>>;
+            tint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    footer: z.ZodObject<{
+        variant: z.ZodEnum<{
+            columns: "columns";
+            simple: "simple";
+        }>;
+        maxWidth: z.ZodEnum<{
+            full: "full";
+            container: "container";
+        }>;
+        background: z.ZodDefault<z.ZodObject<{
+            type: z.ZodEnum<{
+                image: "image";
+                color: "color";
+                gradient: "gradient";
+            }>;
+            color: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            gradient: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    linear: "linear";
+                    radial: "radial";
+                }>;
+                angle: z.ZodOptional<z.ZodNumber>;
+                position: z.ZodOptional<z.ZodString>;
+                stops: z.ZodArray<z.ZodObject<{
+                    color: z.ZodString;
+                    position: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            image: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    image: "image";
+                    video: "video";
+                }>;
+                purpose: z.ZodOptional<z.ZodString>;
+                placeholder: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                assetId: z.ZodOptional<z.ZodString>;
+                src: z.ZodOptional<z.ZodString>;
+                alt: z.ZodOptional<z.ZodString>;
+                width: z.ZodOptional<z.ZodNumber>;
+                height: z.ZodOptional<z.ZodNumber>;
+                storageBucket: z.ZodOptional<z.ZodString>;
+                storagePath: z.ZodOptional<z.ZodString>;
+                transform: z.ZodOptional<z.ZodObject<{
+                    rect: z.ZodOptional<z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>>;
+                    hotspot: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        radius: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            textColor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    buttons: z.ZodOptional<z.ZodObject<{
+        global: z.ZodObject<{
+            cornerStyle: z.ZodEnum<{
+                square: "square";
+                rounded: "rounded";
+                pill: "pill";
+            }>;
+            cornerRadius: z.ZodOptional<z.ZodNumber>;
+            shadow: z.ZodEnum<{
+                none: "none";
+                medium: "medium";
+                low: "low";
+                high: "high";
+            }>;
+            textTransform: z.ZodEnum<{
+                none: "none";
+                lowercase: "lowercase";
+                uppercase: "uppercase";
+                capitalize: "capitalize";
+            }>;
+            fontWeight: z.ZodUnion<readonly [z.ZodLiteral<500>, z.ZodLiteral<600>, z.ZodLiteral<700>]>;
+            borderWidth: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            hoverTransform: z.ZodEnum<{
+                none: "none";
+                scale: "scale";
+                lift: "lift";
+                press: "press";
+            }>;
+            hoverColor: z.ZodEnum<{
+                none: "none";
+                darken: "darken";
+                brighten: "brighten";
+                saturate: "saturate";
+            }>;
+            gradientStyle: z.ZodOptional<z.ZodEnum<{
+                linear: "linear";
+                radial: "radial";
+                conic: "conic";
+            }>>;
+            gradientAngle: z.ZodOptional<z.ZodNumber>;
+            gradientSharpness: z.ZodOptional<z.ZodEnum<{
+                medium: "medium";
+                smooth: "smooth";
+                hard: "hard";
+            }>>;
+        }, z.core.$strip>;
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodBoolean;
+            priority: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            background: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"solid">;
+                colorToken: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"gradient">;
+                stops: z.ZodArray<z.ZodString>;
+                direction: z.ZodEnum<{
+                    "to-r": "to-r";
+                    "to-l": "to-l";
+                    "to-t": "to-t";
+                    "to-b": "to-b";
+                    "to-tr": "to-tr";
+                    "to-tl": "to-tl";
+                    "to-br": "to-br";
+                    "to-bl": "to-bl";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"transparent">;
+            }, z.core.$strip>], "type">;
+            textColorToken: z.ZodString;
+            borderRadius: z.ZodString;
+            shadow: z.ZodOptional<z.ZodObject<{
+                elevation: z.ZodEnum<{
+                    none: "none";
+                    medium: "medium";
+                    low: "low";
+                    high: "high";
+                }>;
+                softness: z.ZodNullable<z.ZodEnum<{
+                    soft: "soft";
+                    crisp: "crisp";
+                    hard: "hard";
+                }>>;
+                position: z.ZodDefault<z.ZodEnum<{
+                    bottom: "bottom";
+                    "bottom-right": "bottom-right";
+                }>>;
+            }, z.core.$strip>>;
+            border: z.ZodOptional<z.ZodObject<{
+                widthClass: z.ZodString;
+                colorToken: z.ZodString;
+            }, z.core.$strip>>;
+            padding: z.ZodOptional<z.ZodString>;
+            fontSize: z.ZodOptional<z.ZodString>;
+            effects: z.ZodOptional<z.ZodObject<{
+                base: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    effectId: z.ZodString;
+                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$strip>>>;
+                hover: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    effectId: z.ZodString;
+                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$strip>>>;
+                active: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    effectId: z.ZodString;
+                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$strip>>>;
+                focus: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    effectId: z.ZodString;
+                    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        sizes: z.ZodOptional<z.ZodObject<{
+            sm: z.ZodObject<{
+                padding: z.ZodString;
+                fontSize: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            md: z.ZodObject<{
+                padding: z.ZodString;
+                fontSize: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            lg: z.ZodObject<{
+                padding: z.ZodString;
+                fontSize: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    cards: z.ZodOptional<z.ZodObject<{
+        variants: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodBoolean;
+            priority: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>;
+            background: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"solid">;
+                colorToken: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"gradient">;
+                fromToken: z.ZodString;
+                toToken: z.ZodString;
+                direction: z.ZodEnum<{
+                    "to-r": "to-r";
+                    "to-l": "to-l";
+                    "to-t": "to-t";
+                    "to-b": "to-b";
+                    "to-tr": "to-tr";
+                    "to-tl": "to-tl";
+                    "to-br": "to-br";
+                    "to-bl": "to-bl";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"transparent">;
+            }, z.core.$strip>], "type">;
+            spacing: z.ZodEnum<{
+                none: "none";
+                medium: "medium";
+                compact: "compact";
+                cozy: "cozy";
+                comfortable: "comfortable";
+                spacious: "spacious";
+            }>;
+            shadow: z.ZodOptional<z.ZodObject<{
+                elevation: z.ZodEnum<{
+                    none: "none";
+                    medium: "medium";
+                    low: "low";
+                    high: "high";
+                }>;
+                softness: z.ZodNullable<z.ZodEnum<{
+                    soft: "soft";
+                    crisp: "crisp";
+                    hard: "hard";
+                }>>;
+                position: z.ZodDefault<z.ZodEnum<{
+                    bottom: "bottom";
+                    "bottom-right": "bottom-right";
+                }>>;
+            }, z.core.$strip>>;
+            corners: z.ZodOptional<z.ZodEnum<{
+                square: "square";
+                rounded: "rounded";
+                pill: "pill";
+                soft: "soft";
+            }>>;
+            border: z.ZodOptional<z.ZodObject<{
+                widthClass: z.ZodString;
+                colorToken: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    accordions: z.ZodOptional<z.ZodObject<{
+        background: z.ZodObject<{
+            type: z.ZodLiteral<"solid">;
+            colorToken: z.ZodString;
+        }, z.core.$strip>;
+        spacing: z.ZodEnum<{
+            none: "none";
+            medium: "medium";
+            compact: "compact";
+            cozy: "cozy";
+            comfortable: "comfortable";
+            spacious: "spacious";
+        }>;
+        corners: z.ZodNullable<z.ZodEnum<{
+            square: "square";
+            rounded: "rounded";
+            pill: "pill";
+            soft: "soft";
+        }>>;
+        border: z.ZodNullable<z.ZodObject<{
+            widthClass: z.ZodString;
+            colorToken: z.ZodString;
+        }, z.core.$strip>>;
+        shadow: z.ZodNullable<z.ZodObject<{
+            elevation: z.ZodEnum<{
+                none: "none";
+                medium: "medium";
+                low: "low";
+                high: "high";
+            }>;
+            softness: z.ZodNullable<z.ZodEnum<{
+                soft: "soft";
+                crisp: "crisp";
+                hard: "hard";
+            }>>;
+            position: z.ZodEnum<{
+                bottom: "bottom";
+                "bottom-right": "bottom-right";
+            }>;
+        }, z.core.$strip>>;
+        icon: z.ZodObject<{
+            style: z.ZodEnum<{
+                caret: "caret";
+                "plus-minus": "plus-minus";
+                chevron: "chevron";
+                arrow: "arrow";
+                "circle-plus-minus": "circle-plus-minus";
+            }>;
+            position: z.ZodEnum<{
+                left: "left";
+                right: "right";
+            }>;
+            size: z.ZodEnum<{
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+            }>;
+        }, z.core.$strip>;
+        trigger: z.ZodObject<{
+            textColorToken: z.ZodString;
+            fontWeight: z.ZodNullable<z.ZodEnum<{
+                bold: "bold";
+                medium: "medium";
+                regular: "regular";
+                semibold: "semibold";
+            }>>;
+        }, z.core.$strip>;
+        hover: z.ZodObject<{
+            backgroundColorToken: z.ZodOptional<z.ZodString>;
+            textColorToken: z.ZodOptional<z.ZodString>;
+            borderColorToken: z.ZodOptional<z.ZodString>;
+            scale: z.ZodOptional<z.ZodNumber>;
+            shadowElevation: z.ZodOptional<z.ZodEnum<{
+                medium: "medium";
+                low: "low";
+                high: "high";
+            }>>;
+        }, z.core.$strip>;
+        content: z.ZodObject<{
+            textColorToken: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    inputs: z.ZodOptional<z.ZodObject<{
+        base: z.ZodObject<{
+            background: z.ZodObject<{
+                type: z.ZodLiteral<"solid">;
+                colorToken: z.ZodString;
+            }, z.core.$strip>;
+            textColorToken: z.ZodString;
+            border: z.ZodObject<{
+                widthClass: z.ZodString;
+                colorToken: z.ZodString;
+            }, z.core.$strip>;
+            corners: z.ZodNullable<z.ZodEnum<{
+                square: "square";
+                rounded: "rounded";
+                pill: "pill";
+                soft: "soft";
+            }>>;
+            shadow: z.ZodNullable<z.ZodObject<{
+                elevation: z.ZodEnum<{
+                    none: "none";
+                    medium: "medium";
+                    low: "low";
+                }>;
+                softness: z.ZodNullable<z.ZodEnum<{
+                    soft: "soft";
+                    crisp: "crisp";
+                    hard: "hard";
+                }>>;
+            }, z.core.$strip>>;
+            spacing: z.ZodEnum<{
+                medium: "medium";
+                compact: "compact";
+                cozy: "cozy";
+                comfortable: "comfortable";
+            }>;
+            fontSize: z.ZodEnum<{
+                sm: "sm";
+                lg: "lg";
+                base: "base";
+            }>;
+        }, z.core.$strip>;
+        label: z.ZodObject<{
+            textColorToken: z.ZodString;
+            fontWeight: z.ZodEnum<{
+                bold: "bold";
+                medium: "medium";
+                regular: "regular";
+                semibold: "semibold";
+            }>;
+            fontSize: z.ZodEnum<{
+                xs: "xs";
+                sm: "sm";
+                base: "base";
+            }>;
+        }, z.core.$strip>;
+        focus: z.ZodObject<{
+            ringColorToken: z.ZodString;
+            ringWidth: z.ZodEnum<{
+                1: "1";
+                2: "2";
+                3: "3";
+            }>;
+            borderColorToken: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        error: z.ZodObject<{
+            borderColorToken: z.ZodString;
+            textColorToken: z.ZodString;
+        }, z.core.$strip>;
+        disabled: z.ZodObject<{
+            backgroundColorToken: z.ZodString;
+            textColorToken: z.ZodString;
+            opacity: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    customCss: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PaletteMeta = z.infer<typeof paletteMetaSchema>;
+type Theme = z.infer<typeof themeSchema>;
+type HydratedTheme = Omit<Theme, 'palette'> & {
+    palette: ExpandedPalette;
+};
+
+type SiteHeaderContent = Record<string, never>;
+
+type InternalLinkValue = {
+    kind: 'internal';
+    routeId: string;
+    entityId: string;
+    entityType: 'page' | 'content';
+    href: string;
+    title: string;
+    typeLabel: string;
+    contentTypeKey?: string | null;
+    contentTypeName?: string | null;
+    updatedAt?: string | null;
+};
+type ExternalLinkValue = {
+    kind: 'external';
+    href: string;
+};
+type CustomLinkValue = {
+    kind: 'url';
+    href: string;
+};
+type LinkValue = InternalLinkValue | ExternalLinkValue | CustomLinkValue;
+
+type SiteFooterLink = {
+    label: string;
+    link: LinkValue | null;
+    target?: string | null;
+    rel?: string | null;
+};
+type SiteFooterLinkGroup = {
+    title?: string | null;
+    links: SiteFooterLink[];
+};
+type SiteFooterContent = {
+    bottomText?: unknown;
+    linkGroups?: SiteFooterLinkGroup[];
+};
+
+type AdminProfileRole = CamelizeKeys<DbRow<'profile_roles'>>;
+type StartImpersonationRequest = {
+    targetUserId: string;
+    tenantId?: string | null;
+    scope?: ImpersonationScope;
+    reason?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+type StartImpersonationResponse = {
+    sessionId: string;
+    scope: ImpersonationScope;
+    targetUserId: string;
+    tenantId: string | null;
+    expiresAt: string;
+};
+type StopImpersonationRequest = {
+    sessionId?: string | null;
+    reason?: string | null;
+};
+type StopImpersonationResponse = {
+    ok: boolean;
+};
+type UpsertAdminRoleRequest = {
+    userId: string;
+    role: DbRow<'profile_roles'>['role'];
+    tenantId?: string | null;
+    reason?: string | null;
+};
+type RevokeAdminRoleRequest = UpsertAdminRoleRequest;
+type AdminRoleMutationResponse = {
+    roles: AdminProfileRole[];
+};
+
+type RouteMetadataPayload = {
+    draftTitle?: string;
+    draftSlug?: string;
+    draftStatus?: 'draft' | 'scheduled' | 'published';
+    publishedAt?: string | null;
+    draftMetaTitle?: string | null;
+    draftMetaDescription?: string | null;
+    ogImageId?: string | null;
+};
+type RouteMetadataResponse = {
+    route: {
+        id: string;
+        siteId: string;
+        nodeId: string | null;
+        nodeType: 'page' | 'content_entry' | null;
+        draftTitle: string | null;
+        draftPath: string | null;
+        draftStatus: string | null;
+        publishedTitle: string | null;
+        publishedPath: string | null;
+        status: string | null;
+        publishedAt: string | null;
+        draftMetaTitle: string | null;
+        draftMetaDescription: string | null;
+        publishedMetaTitle: string | null;
+        publishedMetaDescription: string | null;
+        ogImageId: string | null;
+        draftUpdatedAt: string | null;
+        updatedBy: string | null;
+    };
+};
+
+/**
+ * SDK Site Configuration Types (local definition to avoid circular dependency)
+ *
+ * These types mirror the canonical definitions in @riverbankcms/sdk/config but are
+ * defined locally to avoid circular dependency between @riverbankcms/api and @riverbankcms/sdk.
+ *
+ * The actual validation schema lives in @riverbankcms/sdk/config, which should be used
+ * when validating config data. These types are for API response typing only.
+ */
+/** SDK theme palette - maps token names to CSS color values */
+type SdkThemePalette = Record<string, string>;
+/** SDK theme configuration */
+interface SdkThemeConfig {
+    palette: SdkThemePalette;
+}
+/** Section background with token reference */
+interface SdkSectionBackground {
+    id: string;
+    label: string;
+    token: string;
+}
+interface SdkSectionOptionsConfig {
+    backgroundColor?: boolean;
+    backgroundImage?: boolean;
+    backgroundGradient?: boolean;
+    spacing?: ('compact' | 'default' | 'spacious')[] | boolean;
+    textColor?: boolean;
+}
+interface SdkContainerOptionsConfig {
+    maxWidth?: ('narrow' | 'default' | 'wide' | 'full')[] | boolean;
+    alignment?: ('left' | 'center' | 'right')[] | boolean;
+}
+interface SdkSiteStyleConfig {
+    sectionBackgrounds?: SdkSectionBackground[];
+    sectionOptions?: SdkSectionOptionsConfig;
+    containerOptions?: SdkContainerOptionsConfig;
+}
+/**
+ * Field select option for SDK-provided field options.
+ *
+ * Note: This mirrors FieldSelectOption from @riverbankcms/sdk/config for use in API responses.
+ * The API package cannot depend on SDK, so these types are duplicated here.
+ */
+interface SdkFieldSelectOption {
+    value: string;
+    label: string;
+}
+/**
+ * Per-field configuration within a block.
+ *
+ * Note: This mirrors BlockFieldConfig from @riverbankcms/sdk/config for use in API responses.
+ */
+interface SdkBlockFieldConfig {
+    options?: SdkFieldSelectOption[];
+}
+/**
+ * Per-block field configurations map.
+ *
+ * Note: This mirrors BlockFieldOptionsMap from @riverbankcms/sdk/config for use in API responses.
+ */
+type SdkBlockFieldOptionsMap = Record<string, Record<string, SdkBlockFieldConfig>>;
+interface RiverbankSiteConfig {
+    theme?: SdkThemeConfig;
+    styles?: SdkSiteStyleConfig;
+    /** Custom blocks defined by SDK sites */
+    customBlocks?: SdkCustomBlock[];
+    blockFieldOptions?: SdkBlockFieldOptionsMap;
+}
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD";
+type ApiResponseKind = 'json' | 'stream' | 'text' | 'void';
+type ApiAuthRequirement = 'public' | 'user' | 'admin' | 'service';
+
+type APIEndpoint<TBody = unknown, TQuery = unknown, TResponse = unknown> = {
+    path: string;
+    method: HTTPMethod;
+    body?: TBody;
+    query?: TQuery;
+    response?: TResponse;
+    revalidate?: number;
+    tags?: string[];
+    responseKind?: ApiResponseKind;
+    auth?: ApiAuthRequirement;
+};
+type SiteBriefRecord = CamelizeKeys<DbRow<'site_briefs'>>;
+type SiteProposalSelectionRecord = CamelizeKeys<DbRow<'site_proposal_selections'>>;
+type AdminInviteRow = DbRow<'admin_invites'>;
+type AllowedEmailDomainRow = DbRow<'allowed_email_domains'>;
+type AdminInvite = CamelizeKeys<AdminInviteRow>;
+type AllowedEmailDomain = CamelizeKeys<AllowedEmailDomainRow>;
+type PageRouteRecord = ContentRouteRecord & {
+    canonicalUrl?: string | null;
+    draftUpdatedAt?: string | null;
+    createdAt?: string | null;
+    createdBy?: string | null;
+    updatedAt?: string | null;
+    updatedBy?: string | null;
+};
+type PageRecord = {
+    id: string;
+    siteId: string;
+    routeId: string;
+    purpose: string;
+    title: string;
+    draftTitle: string;
+    path: string;
+    draftPath: string;
+    slug: string | null;
+    draftSlug: string | null;
+    status: ContentEntryStatus;
+    draftStatus: ContentEntryStatus;
+    publishedAt: string | null;
+    draftUpdatedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string | null;
+    route: PageRouteRecord | null;
+};
+type NavigationMenuRecord = CamelizeKeys<DbRow<'navigation_menus'>>;
+type NavigationItemRecord = CamelizeKeys<DbRow<'navigation_items'>>;
+type NavigationMenuWithItems = NavigationMenuRecord & {
+    items: NavigationItemRecord[];
+};
+type SiteRole = 'owner' | 'administrator' | 'editor';
+type SiteMemberProfile = {
+    displayName: string | null;
+    avatarUrl: string | null;
+};
+type SiteMember = {
+    id: string;
+    siteId: string;
+    userId: string;
+    role: SiteRole;
+    invitedBy: string | null;
+    acceptedAt: string | null;
+    removedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+    profile: SiteMemberProfile | null;
+    isCurrentUser: boolean;
+};
+type BlockListItem = {
+    id: string;
+    kind: string;
+    purpose?: string | null;
+    orderIndex?: number | null;
+    content?: Record<string, unknown> | null;
+    draftContent?: Record<string, unknown> | null;
+    publishedContent?: Record<string, unknown> | null;
+};
+type SiteInvitation = {
+    id: string;
+    siteId: string;
+    email: string;
+    role: SiteRole;
+    invitedBy: string | null;
+    expiresAt: string | null;
+    acceptedAt: string | null;
+    acceptedBy: string | null;
+    revokedAt: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type SiteAccessSummary = {
+    membershipRole: SiteRole | null;
+    canInvite: boolean;
+    canManage: boolean;
+    canTransferOwnership: boolean;
+};
+type SitePlanSummaryResponse = {
+    planId: string;
+    capabilities: FeatureKey[];
+    maxCollaborators: number | null;
+    canInviteEditors: boolean;
+    canInviteAdmins: boolean;
+    currentCollaborators: number;
+};
+type ListSiteMembersResponse = {
+    members: SiteMember[];
+    invitations: SiteInvitation[];
+    access: SiteAccessSummary;
+    plan: SitePlanSummaryResponse;
+};
+type AuthFieldKey = 'email' | 'password' | 'confirmPassword' | 'name' | 'terms' | 'magicLink';
+type AuthSubmissionErrorReason = 'validation' | 'turnstile' | 'supabase' | 'already_registered' | 'rate_limited' | 'email' | 'closed' | 'invalid_credentials' | 'not_confirmed' | 'not_allowed';
+type AuthSubmissionSuccess = {
+    status: 'success';
+    message: string;
+    redirectTo?: string;
+    flash?: Record<string, unknown>;
+};
+type AuthSubmissionError = {
+    status: 'error';
+    reason: AuthSubmissionErrorReason;
+    message: string;
+    fieldErrors?: Partial<Record<AuthFieldKey, string>>;
+    retryAfterSeconds?: number;
+};
+type AuthSubmissionResult = AuthSubmissionSuccess | AuthSubmissionError;
+type ReauthSubmissionResult = AuthSubmissionResult & {
+    setReenrollCookie?: boolean;
+};
+type DomainAvailability = {
+    domain: string;
+    available: boolean;
+    price?: number;
+    currency?: string;
+    premium?: boolean;
+    reason?: string;
+    source?: 'lookup' | 'suggestion' | 'heuristic';
+};
+type SiteDomainRecord = CamelizeKeys<DbRow<'site_domains'>>;
+type SiteDomainContactPayload = {
+    firstName: string;
+    lastName: string;
+    organization?: string;
+    addressLine1: string;
+    addressLine2?: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+    phone: string;
+    email: string;
+};
+type ApplySeoChangesRequest = {
+    siteId: string;
+    target: {
+        type: 'page';
+        pageId: string;
+    };
+    changes: {
+        title?: string;
+        metaTitle?: string;
+        metaDescription?: string | null;
+    };
+};
+type ApplySeoChangesResponse = {
+    ok: true;
+    pageId: string;
+    routeId: string | null;
+    draftTitle: string | null;
+    draftMetaTitle: string | null;
+    draftMetaDescription: string | null;
+};
+type LookupSiteDomainRequest = {
+    query: string;
+};
+type LookupSiteDomainResponse = {
+    domains: DomainAvailability[];
+};
+type RegisterSiteDomainRequest = {
+    domain: string;
+    useProfileContact?: boolean;
+    contact?: SiteDomainContactPayload;
+    saveContactToProfile?: boolean;
+};
+type RegisterSiteDomainResponse = {
+    domain: SiteDomainRecord;
+};
+type AddCustomDomainRequest = {
+    domain: string;
+};
+type AddCustomDomainResponse = {
+    domain: SiteDomainRecord;
+    vercel: {
+        verified: boolean;
+        verification?: Array<{
+            type: string;
+            domain: string;
+            value: string;
+            reason: string;
+        }>;
+    };
+};
+type DomainSearchResultResponse = {
+    query: string;
+    primary: DomainAvailability | null;
+    tldAlternatives: DomainAvailability[];
+    nameVariants: DomainAvailability[];
+    suggestions: DomainAvailability[];
+    errors: string[];
+};
+type AnalyticsPreset = '1d' | '7d' | '30d' | '90d' | '365d';
+type AnalyticsReportQuery = {
+    siteId: string;
+    period?: AnalyticsPreset;
+    from?: string;
+    to?: string;
+};
+type AnalyticsSeriesPoint = {
+    date: string;
+    pageViews: number;
+    uniqueVisitors: number;
+    conversions: number;
+};
+type AnalyticsTopPage = {
+    path: string;
+    views: number;
+    conversions: number;
+    conversionRate: number;
+};
+type AnalyticsReferrer = {
+    source: string;
+    visits: number;
+};
+type AnalyticsTotals = {
+    visits: number;
+    uniqueVisitors: number;
+    conversions: number;
+};
+type AnalyticsReportResponse = {
+    range: {
+        from: string;
+        to: string;
+        preset?: AnalyticsPreset | null;
+    };
+    series: AnalyticsSeriesPoint[];
+    totals: AnalyticsTotals;
+    breakdown: {
+        conversionsByEvent: Record<'cta_click' | 'form_submit' | string, number>;
+    };
+    topPages: AnalyticsTopPage[];
+    topReferrers: AnalyticsReferrer[];
+    partial?: boolean;
+    goLiveAt: string | null;
+    clamped?: boolean;
+    noDataYet?: boolean;
+};
+type AnalyticsReportFilters = Omit<AnalyticsReportQuery, 'siteId'>;
+type RegisterDomainContactInput = SiteDomainContactPayload;
+type RegisterDomainRequestPayload = {
+    siteId: string;
+    domain: string;
+    years?: number;
+    useProfileContact?: boolean;
+    contact?: RegisterDomainContactInput;
+    saveContactToProfile?: boolean;
+};
+type RegisterDomainResponse = {
+    domain: SiteDomainRecord;
+    registration: {
+        orderId: string;
+        status: string;
+    };
+};
+type SetHomepageRequest = {
+    pageId: string;
+};
+type SetHomepageResponse = {
+    homepage: PageRecord;
+    previous?: PageRecord | null;
+};
+type InviteSiteMemberRequest = {
+    email: string;
+    role: Exclude<SiteRole, 'owner'>;
+};
+type InviteSiteMemberResponse = {
+    invitation: SiteInvitation;
+    token: string;
+};
+type UpdateSiteMemberRoleRequest = {
+    role: Exclude<SiteRole, 'owner'>;
+};
+type UpdateSiteMemberRoleResponse = {
+    member: SiteMember;
+};
+type RemoveSiteMemberResponse = {
+    success: boolean;
+};
+type RevokeSiteInvitationResponse = {
+    invitation: SiteInvitation | null;
+};
+type TransferSiteOwnershipRequest = {
+    memberId: string;
+};
+type TransferSiteOwnershipResponse = {
+    siteId: string;
+    ownerId: string;
+};
+type AcceptSiteInvitationRequest = {
+    token: string;
+};
+type AcceptSiteInvitationResponse = {
+    membership: SiteMember;
+};
+type InternalLinkRoutablePayload = {
+    kind: 'internal';
+    routeId: string;
+    entityId: string;
+    entityType: 'page' | 'content';
+    href: string;
+    title: string;
+    typeLabel: string;
+    contentTypeKey?: string | null;
+    contentTypeName?: string | null;
+    updatedAt?: string | null;
+};
+type LinkPayload = InternalLinkRoutablePayload | {
+    kind: 'external';
+    href: string;
+} | {
+    kind: 'url';
+    href: string;
+};
+type RoutableContentItem = {
+    routeId: string;
+    entityId: string;
+    entityType: 'page' | 'content';
+    contentTypeKey?: string | null;
+    contentTypeName?: string | null;
+    title: string;
+    draftTitle: string | null;
+    path: string;
+    draftPath: string | null;
+    status: DbRow<'site_routes'>['status'];
+    draftStatus: DbRow<'site_routes'>['draft_status'];
+    typeLabel: string;
+    updatedAt: string | null;
+};
+type MfaFactorSummary = {
+    id: string;
+    type: 'totp' | 'phone' | (string & {});
+    status: 'verified' | 'unverified' | 'pending' | 'failed' | (string & {});
+    friendlyName: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+type MfaOverviewPayload = {
+    userId: string;
+    requiresEnrollment: boolean;
+    mfaEnrolled: boolean;
+    mfaEnrolledAt: string | null;
+    factors: MfaFactorSummary[];
+    verifiedCount: number;
+    totpFactors: MfaFactorSummary[];
+    pendingTotpFactor: MfaFactorSummary | null;
+    loadError: string | null;
+};
+type MfaTotpEnrollResponse = {
+    factorId: string;
+    type: 'totp';
+    friendlyName: string | null;
+    secret: string;
+    uri: string;
+    qrCode: string;
+    challengeId: string;
+    challengeExpiresAt: number;
+};
+type MfaTotpVerifyRequest = {
+    factorId: string;
+    code: string;
+    challengeId?: string | null;
+};
+type MfaTotpVerifyResponse = {
+    factorId: string;
+    challengeId: string;
+    expiresIn: number;
+    mfaVerified: true;
+};
+type MfaTotpActivateRequest = {
+    requireEnrollment?: boolean;
+};
+type MfaOverviewResponse = {
+    overview: MfaOverviewPayload;
+};
+type MfaPhoneEnrollRequest = {
+    phone: string;
+    friendlyName?: string;
+};
+type MfaPhoneEnrollResponse = {
+    factorId: string;
+    phone: string;
+    friendlyName: string | null;
+    challengeId: string;
+    challengeExpiresAt: string | number;
+};
+type MfaPhoneChallengeRequest = {
+    factorId: string;
+};
+type MfaPhoneChallengeResponse = {
+    factorId: string;
+    challengeId: string;
+    challengeExpiresAt: string | number;
+};
+type MfaPhoneVerifyRequest = {
+    factorId: string;
+    code: string;
+    challengeId?: string | null;
+    requireEnrollment?: boolean;
+};
+type MfaBackupCodeSummary = {
+    sequence: number;
+    codeHint: string;
+    usedAt: string | null;
+};
+type MfaBackupCodesOverview = {
+    batchId: string | null;
+    rotatedAt: string | null;
+    totalCodes: number;
+    unusedCodes: number;
+    codes: MfaBackupCodeSummary[];
+};
+type MfaBackupCodesOverviewResponse = {
+    overview: MfaBackupCodesOverview;
+};
+type MfaBackupCodesRotateResponse = {
+    batchId: string;
+    rotatedAt: string;
+    count: number;
+    codes: string[];
+};
+type CreateAdminInviteRequest = {
+    email: string;
+    role: DbRow<'profile_roles'>['role'];
+    tenantId?: string | null;
+    expiresAt?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+type CreateAdminInviteResponse = {
+    invite: AdminInvite;
+    token: string;
+};
+type ListAdminInvitesResponse = {
+    invites: AdminInvite[];
+};
+type RevokeAdminInviteResponse = {
+    invite: AdminInvite;
+};
+type CreateAdminUserRequest = {
+    email: string;
+    displayName?: string;
+    sendInvite?: boolean;
+};
+type CreateAdminUserResponse = {
+    user: {
+        id: string;
+        email: string;
+        displayName?: string;
+        createdAt: string;
+    };
+    inviteSent: boolean;
+};
+type AcceptAdminInviteRequest = {
+    token: string;
+};
+type AcceptAdminInviteResponse = {
+    invite: AdminInvite;
+};
+type ListAllowedDomainsResponse = {
+    domains: AllowedEmailDomain[];
+};
+type CreateAllowedDomainRequest = {
+    domain: string;
+    tenantId?: string | null;
+};
+type CreateAllowedDomainResponse = {
+    domain: AllowedEmailDomain;
+};
+type DeleteAllowedDomainResponse = {
+    domain: AllowedEmailDomain;
+};
+type SiteDeploymentMode = 'managed' | 'headless_cms' | 'headless_full';
+type AdminCreateSiteRequest = {
+    title: string;
+    slug: string;
+    ownerEmail: string;
+    deploymentMode: SiteDeploymentMode;
+};
+type AdminCreateSiteResponse = {
+    site: {
+        id: string;
+        title: string;
+        slug: string;
+        deployment_mode: SiteDeploymentMode;
+        created_at: string;
+    };
+};
+type ChangePlanRequest = {
+    planId: string;
+    interval: BillingInterval;
+    prorationBehavior?: 'create_prorations' | 'always_invoice' | 'none';
+};
+type ChangePlanResponse = {
+    membership: MembershipState | null;
+};
+type AdminChangePlanRequest = ChangePlanRequest & {
+    userId: string;
+    reason?: string;
+    bypassProration?: boolean;
+};
+type AdminChangePlanResponse = ChangePlanResponse;
+type BillingPriceOverride = {
+    id: string;
+    userId: string;
+    planId: string;
+    interval: 'month' | 'year';
+    amountCents: number;
+    currency: string;
+    validFrom: string | null;
+    validUntil: string | null;
+    isActive: boolean;
+    createdBy: string | null;
+    reason: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type AdminGetPriceOverrideQuery = {
+    userId: string;
+    planId: string;
+    interval: 'month' | 'year';
+};
+type AdminGetPriceOverrideResponse = {
+    hasOverride: boolean;
+    override: BillingPriceOverride | null;
+    formattedPrice: string | null;
+};
+type AdminUpsertPriceOverrideRequest = {
+    userId: string;
+    planId: string;
+    interval: 'month' | 'year';
+    amountCents: number;
+    currency?: string;
+    validFrom?: string | null;
+    validUntil?: string | null;
+    reason?: string;
+};
+type AdminUpsertPriceOverrideResponse = {
+    override: BillingPriceOverride;
+};
+type AdminDeletePriceOverrideRequest = {
+    userId: string;
+    planId: string;
+    interval: 'month' | 'year';
+    reason?: string;
+};
+type AdminDeletePriceOverrideResponse = {
+    success: boolean;
+};
+type TableName = keyof DbDatabase['public']['Tables'];
+type DTOType<K extends TableName> = Partial<CamelizeKeys<DbRow<K>>>;
+type GetBriefResponse = {
+    brief: SiteBriefRecord | null;
+};
+type BriefTurnEnvelope = DTOType<'brief_turn_envelopes'>;
+type SiteSpecEnvelope = DTOType<'site_spec_envelopes'>;
+type CreateBriefTurnRequest = {
+    envelope: BriefTurnEnvelope;
+    briefId: string;
+};
+type CreateBriefTurnResponse = {
+    briefTurn: BriefTurnEnvelope;
+};
+type SiteBriefStatePatch = Partial<SiteBriefRecord> & Record<string, unknown>;
+type AiBriefTurn = {
+    nextState: 'brief_collecting' | 'brief_ready';
+    statePatch: SiteBriefStatePatch;
+    questions?: string[];
+    message: string;
+};
+type PrototypeClientBrief = {
+    site_id: string;
+    title: string;
+    entity_type: string;
+    entity_name: string;
+    field_category: string;
+    primary_purpose: string;
+    secondary_purpose?: string[];
+    audiences?: string[];
+    desired_features?: string[];
+    tone?: string;
+    locations?: string[];
+    inspiration_urls?: string[];
+};
+type PrototypeUncertainty = {
+    question: string;
+    impact: 'high' | 'medium' | 'low';
+    toggle_key: string | null;
+};
+type PrototypeToggleKey = 'enable_blog' | 'add_portfolio' | 'add_faq' | 'add_testimonials' | 'add_gallery' | 'add_about' | 'show_pricing' | 'enable_booking' | 'enable_newsletter' | 'add_cta' | 'enable_reviews' | 'add_team' | 'one_pager' | 'add_contact_map' | 'add_legal';
+type PrototypeProposal = {
+    description: string;
+    style: string;
+    rationale: string;
+    pages: Array<Record<string, unknown>>;
+    assumptions: string[];
+    uncertainties: PrototypeUncertainty[];
+    quick_toggle_keys: PrototypeToggleKey[];
+    custom_toggles: Array<{
+        label: string;
+        description: string | null;
+    }> | null;
+};
+type PrototypeTurn = {
+    message: string;
+    proposals: PrototypeProposal[];
+};
+type PrototypeChatResponse = {
+    text: string | null;
+    output: DbJson;
+    messages: PrototypeTurn[];
+    responseId: string;
+};
+type Site = DbRow<'sites'>;
+type MediaClassifyJobResponse = {
+    id: string;
+    site_id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    asset_ids: string[];
+    next_index: number;
+    force: boolean;
+    requested_by: string | null;
+    prompt: string | null;
+    results: Array<{
+        assetId: string;
+        ok: boolean;
+        skipped?: boolean;
+        error?: string | null;
+    }>;
+    last_error: string | null;
+    created_at: string;
+    updated_at: string;
+    started_at: string | null;
+    completed_at: string | null;
+};
+type MediaLabelSummary = {
+    slug: string;
+    name: string;
+    count: number;
+};
+type MediaSettingsResponse = {
+    siteId: string;
+    persistVariants: boolean;
+    updatedAt: string | null;
+};
+type BookingModuleToggles = {
+    appointments: boolean;
+    events: boolean;
+};
+type BookingReminderOverrides = Record<string, number>;
+type BookingSettings = {
+    modules: BookingModuleToggles;
+    defaultTimezone: string | null;
+    defaultVenueId: string | null;
+    calendarDisplay: 'list' | 'calendar';
+    remindersEnabled: boolean;
+    appointmentReminderHours: number;
+    eventReminderHours: number;
+    appointmentReminderOverrides: BookingReminderOverrides;
+    eventReminderOverrides: BookingReminderOverrides;
+    icsFeedsEnabled: boolean;
+};
+type UpdateBookingSettingsRequest = BookingSettings;
+type BookingSettingsResponse = {
+    settings: BookingSettings;
+};
+type AppointmentResource = {
+    id: string;
+    siteId: string;
+    userId: string | null;
+    displayName: string;
+    bio: string | null;
+    colorHex: string | null;
+    avatarAssetId: string | null;
+    timezone: string;
+    calendarSyncEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateAppointmentResourceRequest = {
+    displayName: string;
+    bio?: string | null;
+    timezone?: string;
+    colorHex?: string | null;
+    calendarSyncEnabled?: boolean;
+};
+type UpdateAppointmentResourceRequest = Partial<CreateAppointmentResourceRequest>;
+type AppointmentResourceResponse = {
+    resource: AppointmentResource;
+};
+type ListAppointmentResourcesResponse = {
+    resources: AppointmentResource[];
+};
+type DeleteResourceResponse = {
+    success: boolean;
+};
+type AppointmentService = {
+    id: string;
+    siteId: string;
+    title: string;
+    slug: string;
+    description: string | null;
+    durationMinutes: number;
+    priceAmount: number | null;
+    priceCurrency: string;
+    bufferBeforeMinutes: number;
+    bufferAfterMinutes: number;
+    colorHex: string | null;
+    isActive: boolean;
+    locationType: 'virtual' | 'in_person' | 'hybrid';
+    venueId: string | null;
+    timezone: string | null;
+    formId: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateAppointmentServiceRequest = {
+    title: string;
+    description?: string | null;
+    durationMinutes: number;
+    priceAmount?: number | null;
+    priceCurrency?: string;
+    bufferBeforeMinutes?: number;
+    bufferAfterMinutes?: number;
+    colorHex?: string | null;
+    isActive?: boolean;
+    locationType?: 'virtual' | 'in_person' | 'hybrid';
+    venueId?: string | null;
+    timezone?: string | null;
+    formId?: string | null;
+};
+type UpdateAppointmentServiceRequest = Partial<CreateAppointmentServiceRequest>;
+type AppointmentServiceResponse = {
+    service: AppointmentService;
+};
+type ListAppointmentServicesResponse = {
+    services: AppointmentService[];
+};
+type DeleteServiceResponse = {
+    success: boolean;
+};
+type ReferenceOption = {
+    id: string;
+    label: string;
+};
+type ReferenceOptionsResponse = {
+    options: ReferenceOption[];
+};
+type AvailabilityRule = {
+    id: string;
+    siteId: string;
+    resourceId: string;
+    serviceId: string | null;
+    weekday: number;
+    startTime: string;
+    endTime: string;
+    minLeadMinutes: number;
+    maxBookingNoticeMinutes: number;
+    bufferMinutes: number;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateAvailabilityRuleRequest = {
+    id?: string;
+    weekday: number;
+    startTime: string;
+    endTime: string;
+    minLeadMinutes?: number;
+    maxBookingNoticeMinutes?: number;
+    bufferMinutes?: number;
+    serviceId?: string | null;
+};
+type ListAvailabilityRulesResponse = {
+    rules: AvailabilityRule[];
+};
+type UpsertAvailabilityRuleResponse = {
+    rule: AvailabilityRule;
+};
+type AppointmentBlackout = {
+    id: string;
+    siteId: string;
+    resourceId: string | null;
+    startsAt: string;
+    endsAt: string;
+    reason: string | null;
+    createdAt: string;
+};
+type CreateBlackoutRequest = {
+    startsAt: string;
+    endsAt: string;
+    reason?: string | null;
+};
+type ListBlackoutsResponse = {
+    blackouts: AppointmentBlackout[];
+};
+type CreateBlackoutResponse = {
+    blackout: AppointmentBlackout;
+};
+type DeleteAvailabilityRuleResponse = {
+    success: boolean;
+};
+type DeleteBlackoutResponse = {
+    success: boolean;
+};
+type TimeSlot = {
+    startAt: string;
+    endAt: string;
+    resourceId: string;
+};
+type GetAvailableSlotsQuery = {
+    serviceId: string;
+    resourceId?: string;
+    startDate: string;
+    endDate: string;
+    timezone?: string;
+};
+type GetAvailableSlotsResponse = {
+    slots: TimeSlot[];
+};
+type CreateAppointmentRequest = {
+    serviceId: string;
+    resourceId: string;
+    startAt: string;
+    endAt: string;
+    customerName: string;
+    customerEmail: string;
+    customerPhone?: string | null;
+    notes?: string | null;
+    timezone?: string;
+};
+type AppointmentRecord = {
+    id: string;
+    siteId: string;
+    serviceId: string;
+    resourceId: string;
+    customerId: string;
+    startAt: string;
+    endAt: string;
+    timezone: string;
+    status: 'pending' | 'confirmed' | 'cancelled' | 'no_show';
+    source: string;
+    metadata: Record<string, unknown>;
+    formSubmissionJson: Record<string, unknown>;
+    reminderScheduledAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+type BookingCustomerRecord = {
+    id: string;
+    siteId: string;
+    name: string | null;
+    email: string | null;
+    phone: string | null;
+    timezone: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateAppointmentResponse = {
+    appointment: AppointmentRecord;
+    customer: BookingCustomerRecord;
+};
+type AccountRevokeSessionsBody = {
+    scope?: 'others' | 'global';
+};
+type AccountRevokeSessionsResponse = {
+    ok: boolean;
+    scope: 'others' | 'global';
+};
+type AccountUpdatePasswordBody = {
+    currentPassword: string;
+    newPassword: string;
+};
+type AccountUpdatePasswordResponse = {
+    ok: boolean;
+    passwordSetAt?: string | null;
+};
+type MediaJobSummaryResponse = {
+    processed: number;
+    skipped: number;
+    failures: number;
+};
+type CreateMediaAssetBody = {
+    siteId: string;
+    storageBucket: string;
+    storagePath: string;
+    filename: string;
+    mimeType: string;
+    width?: number;
+    height?: number;
+    bytes?: number;
+    checksumSha256?: string | null;
+    source?: 'upload' | 'instagram';
+    altText?: string | null;
+    caption?: string | null;
+    exif?: Record<string, unknown> | null;
+};
+type MediaAssetResponse = {
+    id: string;
+    siteId: string;
+    storageBucket: string | null;
+    storagePath: string;
+    filename: string;
+    mimeType: string;
+    width: number | null;
+    height: number | null;
+    bytes: number | null;
+    checksumSha256: string | null;
+    source: 'upload' | 'instagram';
+    altText: string | null;
+    caption: string | null;
+    exif: Record<string, unknown> | null;
+    createdBy: string | null;
+    createdAt: string;
+    updatedAt: string;
+    labels?: Array<{
+        id: number;
+        slug: string;
+        name: string;
+    }>;
+};
+type ContentRouteRecord = {
+    id: string;
+    draftTitle: string;
+    draftPath: string;
+    draftSlug: string | null;
+    draftStatus: 'draft' | 'scheduled' | 'published' | 'archived';
+    draftMetaTitle?: string | null;
+    draftMetaDescription?: string | null;
+    draftUpdatedAt?: string | null;
+    publishedTitle?: string | null;
+    publishedPath?: string | null;
+    publishedSlug?: string | null;
+    publishedMetaTitle?: string | null;
+    publishedMetaDescription?: string | null;
+    publishedAt?: string | null;
+    status?: 'draft' | 'scheduled' | 'published' | 'archived';
+    ogImageId?: string | null;
+};
+type ContentEntryStatus = 'draft' | 'scheduled' | 'published' | 'archived';
+type ContentEntryRecord = {
+    id: string;
+    siteId: string;
+    contentTypeId: string;
+    routeId: string | null;
+    draftVersionId: string | null;
+    publishedVersionId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: string | null;
+    updatedBy: string | null;
+};
+type ContentEntrySummary = {
+    id: string;
+    title: string;
+    status: ContentEntryStatus;
+    slug: string | null;
+    publishAt: string | null;
+    updatedAt: string;
+    draftTitle: string;
+    draftPath: string;
+    routeId: string | null;
+};
+type FormSummary = {
+    id: string;
+    name: string;
+    updatedAt: string | null;
+};
+type FormRecord = CamelizeKeys<DbRow<'forms'>>;
+type FormSubmissionRecord = DbRow<'form_submissions'>;
+type ThemePreferencesRecord = DbRow<'site_theme_preferences'>;
+type ThemeRow = DbRow<'themes'>;
+type ThemeGenerationTurn = {
+    message: string;
+    themes: Theme[];
+};
+type ContentEntryDetail<TContent> = {
+    entry: ContentEntryRecord;
+    route: ContentRouteRecord | null;
+    draftContent: TContent;
+    publishedContent: TContent | null;
+};
+type ContentEntryDetailResponse<TContent = Record<string, unknown>> = {
+    entry: ContentEntryDetail<TContent>;
+};
+type ContentEntryOrPageResponse<TContent = Record<string, unknown>> = ContentEntryDetailResponse<TContent> | {
+    entry: PageRecord;
+};
+type PublishedContentEntryPreview = {
+    id: string;
+    title: string;
+    slug: string;
+    path: string;
+    excerpt: string;
+    publishedAt: string | null;
+    image: {
+        url?: string | null;
+        alt?: string | null;
+    } | null;
+};
+type PublishedContentEntryPreviewResponse = {
+    data: PublishedContentEntryPreview | null;
+};
+type PublishedPostPreviewResponse = PublishedContentEntryPreviewResponse;
+type ContentEntryListStage = 'published' | 'preview';
+type ContentEntryListItem<TContent = Record<string, unknown>> = {
+    id: string;
+    slug: string | null;
+    path: string;
+    title: string;
+    status: ContentEntryStatus;
+    publishedAt: string | null;
+    content: TContent;
+    excerpt: string;
+    routeId: string | null;
+};
+type ListPublishedEntriesResponse<TContent = Record<string, unknown>> = {
+    entries: ContentEntryListItem<TContent>[];
+};
+type UpsertBriefRequest = Partial<CamelizeKeys<SiteBriefRecord>>;
+type UpsertBriefResponse = SiteBriefRecord;
+type SerializedContentTypeSummary = {
+    id: string | null;
+    siteId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    hasPages: boolean;
+    routePattern: string | null;
+};
+type ContentTypeTemplateSummary = SerializedContentTypeSummary & {
+    schema: Record<string, unknown>;
+    titleField: string | null;
+    defaultTemplateId: string | null;
+    templateAddons: string[] | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+type ContentTemplateSummary = {
+    id: string;
+    contentTypeId: string;
+    templateKey: string;
+    name: string;
+    description: string | null;
+    isDefault: boolean;
+    metadata: Record<string, unknown>;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+type ContentTemplateBlockSummary = {
+    id: string;
+    templateId: string;
+    orderIndex: number;
+    blockKind: string;
+    scope: 'entry' | 'template';
+    content: Record<string, unknown> | null;
+    bindings: Record<string, unknown> | null;
+    dataDependencies: Record<string, unknown> | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+type ContentTemplateAddonSummary = {
+    addonKey: string;
+    enabled: boolean;
+    metadata: Record<string, unknown>;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+type ContentAddonDefinition = {
+    addonKey: string;
+    name: string;
+    description: string | null;
+    schemaPatch: DbJson;
+    blockPatch: DbJson;
+    version: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+type ContentTemplateDetailsResponse = {
+    contentType: ContentTypeTemplateSummary;
+    template: ContentTemplateSummary | null;
+    blocks: ContentTemplateBlockSummary[];
+    addons: ContentTemplateAddonSummary[];
+    availableAddons: ContentAddonDefinition[];
+};
+type UpdateContentTemplateBlockRequest = {
+    content: Record<string, unknown>;
+};
+type ApplyContentTemplateAddonRequest = {
+    addonKey: string;
+};
+type UpdateContentTemplateBlockBindingsRequest = {
+    bindings: Record<string, unknown>;
+};
+type CreateTemplateBlockRequest = {
+    blockKind: string;
+    scope: 'entry' | 'template';
+    position?: number;
+};
+type ReorderTemplateBlocksRequest = {
+    blockIds: string[];
+};
+type TransformMetadata = {
+    id: string;
+    summary: string;
+    kind: 'formatter' | 'collection' | 'string' | 'html';
+};
+type GetTransformsResponse = {
+    transforms: TransformMetadata[];
+};
+type SiteGeneralSettingsPayload = {
+    siteTitle: string;
+    logoAssetId: string | null;
+};
+type SiteGeneralSettingsResponse = {
+    settings: SiteGeneralSettingsPayload;
+};
+type SiteLayoutSettingsPayload = {
+    logoAssetId: string | null;
+    header: SiteHeaderContent;
+    footer: SiteFooterContent;
+};
+type SiteLayoutResolvedPayload = SiteLayoutSettingsPayload & {
+    logo?: {
+        assetId: string | null;
+        url: string | null;
+        alt: string | null;
+        width?: number | null;
+        height?: number | null;
+    };
+};
+type SiteLayoutSettingsResponse = {
+    settings: SiteLayoutSettingsPayload;
+};
+type MaintenanceSettingsPayload = {
+    enabled: boolean;
+    message: any;
+};
+type MaintenanceSettingsResponse = {
+    settings: MaintenanceSettingsPayload;
+};
+type SiteBySlugResponse = {
+    site: {
+        id: string;
+        title: string;
+        slug: string;
+        created_at: string;
+        updated_at: string;
+        maintenance_mode_enabled?: boolean | undefined;
+        maintenance_mode_message?: unknown | null | undefined;
+    };
+    theme: Theme;
+    themeId?: string | null;
+    selectionId?: string | null;
+    navigation: NavigationMenuWithItems[];
+    routes: Record<string, {
+        path: string;
+        draftPath: string | null;
+        status: string | null;
+        draftStatus?: string | null;
+        publishedAt?: string | null;
+    }>;
+    layout: SiteLayoutResolvedPayload;
+    customDomain: string | null;
+    sdkConfig?: RiverbankSiteConfig | null;
+};
+type BlockWithContentResponse = {
+    id: string;
+    kind: string;
+    siteId: string;
+    pageId: string | null;
+    draftContentId: string | null;
+    publishedContentId: string | null;
+    draftContent: Record<string, unknown> | null;
+    publishedContent: Record<string, unknown> | null;
+};
+type DevToolsImpersonationResponse = {
+    userId: string;
+    email: string | null;
+    mode: 'superadmin' | 'random';
+};
+type DevToolsSeedResponse = {
+    summary: {
+        usersCreated: number;
+        usersUpdated: number;
+        sitesCreated: number;
+        sitesUpdated: number;
+        pagesCreated: number;
+        pagesUpdated: number;
+        blocksCreated: number;
+    };
+};
+type CreateManualSiteRequest = {
+    title: string;
+    description?: string | null;
+    themeKey: string;
+    contentTypes: Array<'page' | 'post' | 'event' | 'testimonial'>;
+    scaffoldHome: boolean;
+    scaffoldContact: boolean;
+    scaffoldBlog: boolean;
+    invitees?: string[];
+};
+type CreateManualSiteResponse = {
+    siteId: string;
+    slug: string;
+    seeded: {
+        pages: Array<{
+            id: string;
+            name: string;
+            path: string;
+        }>;
+        forms: Array<{
+            id: string;
+            name: string;
+            slug: string;
+        }>;
+        contentTypes: Array<'page' | 'post' | 'event' | 'testimonial'>;
+    };
+};
+type APIEndpoints = {
+    aiContentUpdateChat: APIEndpoint<{
+        messages: AIChatMessage[];
+    }, never, ReadableStream<Uint8Array>>;
+    aiChat: APIEndpoint<{
+        messages: AIChatMessage[];
+    }, never, ReadableStream<Uint8Array>>;
+    aiCreateBriefChat: APIEndpoint<{
+        messages: AIChatMessage[];
+    }, never, AiBriefTurn>;
+    aiPrototypeChat: APIEndpoint<{
+        client: PrototypeClientBrief;
+    }, never, PrototypeChatResponse>;
+    aiPatchDryRun: APIEndpoint<AiPatchRequest, never, AiPatchDryRunResponse>;
+    aiPatchApply: APIEndpoint<AiPatchRequest, never, AiPatchApplyResponse>;
+    aiPlaygroundPropose: APIEndpoint<{
+        request: string;
+    }, {
+        siteId: string;
+        pageId: string;
+    }, {
+        patches: Array<{
+            blockId: string;
+            ops: Array<Record<string, unknown>>;
+            rationale: string;
+        }>;
+        assistantMessage: string;
+        validation: {
+            valid: boolean;
+            issues: string[];
+            filtered: number;
+        };
+    }>;
+    getBrief: APIEndpoint<never, // No body for GET
+    {
+        id?: string;
+    }, // Optional query parameters
+    GetBriefResponse>;
+    createBriefTurn: APIEndpoint<CreateBriefTurnRequest, never, CreateBriefTurnResponse>;
+    aiBriefToSpec: APIEndpoint<{
+        briefId: string;
+    }, never, SiteSpecEnvelope>;
+    upsertBrief: APIEndpoint<UpsertBriefRequest, never, UpsertBriefResponse>;
+    createSite: APIEndpoint<{
+        title: string;
+    }, never, {
+        id: string;
+        title: string;
+    }>;
+    createSiteManual: APIEndpoint<CreateManualSiteRequest, never, CreateManualSiteResponse>;
+    updateSite: APIEndpoint<Partial<Site>, never, Partial<Site>>;
+    deleteSite: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        ok: boolean;
+    }>;
+    listContentEntries: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+    }, {
+        entries: ContentEntrySummary[];
+        contentType: SerializedContentTypeSummary;
+    }>;
+    getContentTemplate: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+    }, ContentTemplateDetailsResponse>;
+    updateContentTemplateBlock: APIEndpoint<UpdateContentTemplateBlockRequest, {
+        siteId: string;
+        type: string;
+        blockId: string;
+    }, ContentTemplateDetailsResponse>;
+    applyContentTemplateAddon: APIEndpoint<ApplyContentTemplateAddonRequest, {
+        siteId: string;
+        type: string;
+    }, ContentTemplateDetailsResponse>;
+    updateContentTemplateBlockBindings: APIEndpoint<UpdateContentTemplateBlockBindingsRequest, {
+        siteId: string;
+        type: string;
+        blockId: string;
+    }, ContentTemplateDetailsResponse>;
+    createTemplateBlock: APIEndpoint<CreateTemplateBlockRequest, {
+        siteId: string;
+        type: string;
+    }, ContentTemplateDetailsResponse>;
+    deleteTemplateBlock: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        blockId: string;
+    }, ContentTemplateDetailsResponse>;
+    reorderTemplateBlocks: APIEndpoint<ReorderTemplateBlocksRequest, {
+        siteId: string;
+        type: string;
+    }, ContentTemplateDetailsResponse>;
+    getTransforms: APIEndpoint<never, never, GetTransformsResponse>;
+    createContentEntry: APIEndpoint<Record<string, unknown> | undefined, {
+        siteId: string;
+        type: string;
+    }, ContentEntryOrPageResponse>;
+    getContentEntry: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, ContentEntryOrPageResponse>;
+    updateContentEntry: APIEndpoint<Record<string, unknown>, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, ContentEntryOrPageResponse>;
+    updateContentEntryContent: APIEndpoint<{
+        data: Record<string, unknown>;
+        optimistic_hash?: string | null;
+    } | {
+        path: string;
+        value: unknown;
+        optimistic_hash?: string | null;
+    }, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, ContentEntryOrPageResponse>;
+    publishContentEntry: APIEndpoint<Record<string, unknown> | undefined, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, ContentEntryOrPageResponse>;
+    discardContentEntry: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, ContentEntryOrPageResponse>;
+    unpublishContentEntry: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, ContentEntryOrPageResponse>;
+    deleteContentEntry: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        entryId: string;
+    }, {
+        ok: boolean;
+    }>;
+    updateRouteMetadata: APIEndpoint<RouteMetadataPayload, {
+        siteId: string;
+        routeId: string;
+    }, RouteMetadataResponse>;
+    listSiteMembers: APIEndpoint<never, {
+        siteId: string;
+    }, ListSiteMembersResponse>;
+    inviteSiteMember: APIEndpoint<InviteSiteMemberRequest, {
+        siteId: string;
+    }, InviteSiteMemberResponse>;
+    updateSiteMemberRole: APIEndpoint<UpdateSiteMemberRoleRequest, {
+        siteId: string;
+        memberId: string;
+    }, UpdateSiteMemberRoleResponse>;
+    authLogin: APIEndpoint<FormData, never, AuthSubmissionResult>;
+    authForgotPassword: APIEndpoint<FormData, never, AuthSubmissionResult>;
+    authRegister: APIEndpoint<FormData, never, AuthSubmissionResult>;
+    authReauthenticate: APIEndpoint<FormData, never, ReauthSubmissionResult>;
+    lookupSiteDomains: APIEndpoint<LookupSiteDomainRequest, {
+        siteId: string;
+    }, LookupSiteDomainResponse>;
+    registerSiteDomain: APIEndpoint<RegisterSiteDomainRequest, {
+        siteId: string;
+    }, RegisterSiteDomainResponse>;
+    addCustomDomain: APIEndpoint<AddCustomDomainRequest, {
+        siteId: string;
+    }, AddCustomDomainResponse>;
+    removeCustomDomain: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        success: boolean;
+    }>;
+    syncCustomDomainToEdgeConfig: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        success: boolean;
+        domain: string;
+        siteId: string;
+        message: string;
+    }>;
+    listAccountDomains: APIEndpoint<never, never, {
+        domains: SiteDomainRecord[];
+    }>;
+    searchDomains: APIEndpoint<{
+        query: string;
+    }, never, {
+        result: DomainSearchResultResponse;
+    }>;
+    registerDomain: APIEndpoint<RegisterDomainRequestPayload, never, RegisterDomainResponse>;
+    assignDomain: APIEndpoint<{
+        siteId: string;
+    }, {
+        domainId: string;
+    }, {
+        domain: SiteDomainRecord;
+    }>;
+    removeSiteMember: APIEndpoint<never, {
+        siteId: string;
+        memberId: string;
+    }, RemoveSiteMemberResponse>;
+    revokeSiteInvitation: APIEndpoint<never, {
+        siteId: string;
+        invitationId: string;
+    }, RevokeSiteInvitationResponse>;
+    transferSiteOwnership: APIEndpoint<TransferSiteOwnershipRequest, {
+        siteId: string;
+    }, TransferSiteOwnershipResponse>;
+    updateSiteGeneralSettings: APIEndpoint<SiteGeneralSettingsPayload, {
+        siteId: string;
+    }, SiteGeneralSettingsResponse>;
+    getSiteLayoutSettings: APIEndpoint<never, {
+        siteId: string;
+    }, SiteLayoutSettingsResponse>;
+    updateSiteLayoutSettings: APIEndpoint<SiteLayoutSettingsPayload, {
+        siteId: string;
+    }, SiteLayoutSettingsResponse>;
+    getMaintenanceSettings: APIEndpoint<never, {
+        siteId: string;
+    }, MaintenanceSettingsResponse>;
+    updateMaintenanceSettings: APIEndpoint<MaintenanceSettingsPayload, {
+        siteId: string;
+    }, MaintenanceSettingsResponse>;
+    setHomepage: APIEndpoint<SetHomepageRequest, {
+        siteId: string;
+    }, SetHomepageResponse>;
+    listContentTypes: APIEndpoint<undefined, {
+        siteId: string;
+    }, {
+        contentTypes: SerializedContentTypeSummary[];
+    }>;
+    enableContentType: APIEndpoint<undefined | Record<string, never>, {
+        siteId: string;
+        key: string;
+    }, {
+        ok: boolean;
+        contentType: SerializedContentTypeSummary;
+    }>;
+    setupContentType: APIEndpoint<{
+        addListingPage?: boolean;
+        addNavItem?: boolean;
+        seedExample?: boolean;
+    } | undefined, {
+        siteId: string;
+        key: string;
+    }, {
+        ok: true;
+        type: string;
+        pageId?: string;
+        navItemId?: string;
+        entryId?: string;
+    }>;
+    adminStartImpersonation: APIEndpoint<StartImpersonationRequest, never, StartImpersonationResponse>;
+    adminStopImpersonation: APIEndpoint<StopImpersonationRequest, never, StopImpersonationResponse>;
+    adminAssignRole: APIEndpoint<UpsertAdminRoleRequest, never, AdminRoleMutationResponse>;
+    adminRevokeRole: APIEndpoint<RevokeAdminRoleRequest, never, AdminRoleMutationResponse>;
+    adminChangePlan: APIEndpoint<AdminChangePlanRequest, never, AdminChangePlanResponse>;
+    changePlan: APIEndpoint<ChangePlanRequest, never, ChangePlanResponse>;
+    mfaTotpEnroll: APIEndpoint<never, never, MfaTotpEnrollResponse>;
+    mfaTotpVerify: APIEndpoint<MfaTotpVerifyRequest, never, MfaTotpVerifyResponse>;
+    mfaTotpActivate: APIEndpoint<MfaTotpActivateRequest | undefined, never, MfaOverviewResponse>;
+    mfaDeleteFactor: APIEndpoint<MfaTotpActivateRequest | undefined, {
+        factorId: string;
+    }, MfaOverviewResponse>;
+    mfaBackupCodesGet: APIEndpoint<never, never, MfaBackupCodesOverviewResponse>;
+    mfaBackupCodesRotate: APIEndpoint<{
+        count?: number;
+    } | undefined, never, MfaBackupCodesRotateResponse>;
+    mfaPhoneEnroll: APIEndpoint<MfaPhoneEnrollRequest, never, MfaPhoneEnrollResponse>;
+    mfaPhoneChallenge: APIEndpoint<MfaPhoneChallengeRequest, never, MfaPhoneChallengeResponse>;
+    mfaPhoneVerify: APIEndpoint<MfaPhoneVerifyRequest, never, MfaOverviewResponse>;
+    accountUpdatePassword: APIEndpoint<AccountUpdatePasswordBody, never, AccountUpdatePasswordResponse>;
+    accountRevokeSessions: APIEndpoint<AccountRevokeSessionsBody, never, AccountRevokeSessionsResponse>;
+    adminListInvites: APIEndpoint<{
+        tenantId?: string | null;
+    }, never, ListAdminInvitesResponse>;
+    adminCreateInvite: APIEndpoint<CreateAdminInviteRequest, never, CreateAdminInviteResponse>;
+    adminRevokeInvite: APIEndpoint<never, {
+        inviteId: string;
+    }, RevokeAdminInviteResponse>;
+    adminCreateUser: APIEndpoint<CreateAdminUserRequest, never, CreateAdminUserResponse>;
+    adminListAllowedDomains: APIEndpoint<{
+        tenantId?: string | null;
+    }, never, ListAllowedDomainsResponse>;
+    adminAddAllowedDomain: APIEndpoint<CreateAllowedDomainRequest, never, CreateAllowedDomainResponse>;
+    adminDeleteAllowedDomain: APIEndpoint<never, {
+        domainId: string;
+    }, DeleteAllowedDomainResponse>;
+    authAcceptInvite: APIEndpoint<AcceptAdminInviteRequest, never, AcceptAdminInviteResponse>;
+    acceptSiteInvitation: APIEndpoint<AcceptSiteInvitationRequest, never, AcceptSiteInvitationResponse>;
+    getNavigationMenus: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    createNavigationMenu: APIEndpoint<{
+        name: string;
+        isPrimary?: boolean;
+        position?: number;
+    }, {
+        siteId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    updateNavigationMenu: APIEndpoint<{
+        name?: string;
+        isPrimary?: boolean;
+        position?: number;
+    }, {
+        siteId: string;
+        menuId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    deleteNavigationMenu: APIEndpoint<never, {
+        siteId: string;
+        menuId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    createNavigationItem: APIEndpoint<{
+        label: string;
+        type: 'link' | 'dropdown';
+        link?: LinkPayload;
+        parentId?: string | null;
+        orderIndex?: number;
+        isCta?: boolean;
+    }, {
+        siteId: string;
+        menuId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    updateNavigationItem: APIEndpoint<{
+        label?: string;
+        type?: 'link' | 'dropdown';
+        link?: LinkPayload;
+        parentId?: string | null;
+        orderIndex?: number;
+        isCta?: boolean;
+    }, {
+        siteId: string;
+        menuId: string;
+        itemId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    deleteNavigationItem: APIEndpoint<never, {
+        siteId: string;
+        menuId: string;
+        itemId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    reorderNavigationItems: APIEndpoint<{
+        items: Array<{
+            id: string;
+            orderIndex: number;
+            parentId: string | null;
+        }>;
+    }, {
+        siteId: string;
+        menuId: string;
+    }, {
+        menus: NavigationMenuWithItems[];
+    }>;
+    getRoutableContent: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        items: RoutableContentItem[];
+    }>;
+    listForms: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        forms: FormSummary[];
+    }>;
+    listBookingForms: APIEndpoint<never, {
+        siteId: string;
+    }, {
+        forms: FormSummary[];
+    }>;
+    createForm: APIEndpoint<{
+        name: string;
+        slug: string;
+        schema: DbJson;
+        settings?: DbJson;
+    }, {
+        siteId: string;
+    }, {
+        form: FormRecord;
+    }>;
+    updateForm: APIEndpoint<{
+        name?: string;
+        schema?: DbJson;
+        settings?: DbJson;
+    }, {
+        siteId: string;
+        slug: string;
+    }, {
+        form: FormRecord;
+    }>;
+    deleteForm: APIEndpoint<never, {
+        siteId: string;
+        slug: string;
+    }, {
+        ok: boolean;
+    }>;
+    listFormSubmissions: APIEndpoint<never, {
+        siteId: string;
+        slug: string;
+        page?: string;
+        perPage?: string;
+        since?: string;
+        until?: string;
+    }, {
+        submissions: FormSubmissionRecord[];
+        page: number;
+        perPage: number;
+        total: number;
+        since: string | null;
+        until: string | null;
+    }>;
+    submitForm: APIEndpoint<{
+        siteId: string;
+        slug: string;
+        data: Record<string, unknown>;
+        meta?: {
+            ip?: string;
+            userAgent?: string;
+            referer?: string;
+            path?: string;
+            honeypot?: string;
+            turnstileToken?: string | null;
+        };
+    }, never, {
+        ok: boolean;
+    }>;
+    getPublicFormById: APIEndpoint<never, {
+        formId: string;
+    }, {
+        form: FormRecord;
+    }>;
+    getPublicBookingServices: APIEndpoint<never, {
+        siteId: string;
+        ids?: string;
+    }, {
+        services: Array<{
+            id: string;
+            siteId: string;
+            title: string;
+            description?: string;
+            durationMinutes?: number;
+        }>;
+    }>;
+    getPublishedPostPreview: APIEndpoint<never, {
+        siteId: string;
+        slug: string;
+    }, PublishedPostPreviewResponse>;
+    getPublishedEntryPreview: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        slug: string;
+    }, PublishedContentEntryPreviewResponse>;
+    listPublishedEntries: APIEndpoint<never, {
+        siteId: string;
+        type: string;
+        limit?: string;
+        order?: 'published_at.asc' | 'published_at.desc';
+        stage?: ContentEntryListStage;
+    }, ListPublishedEntriesResponse>;
+    proposalsSelect: APIEndpoint<{
+        site_id: string;
+        proposal_id: string;
+        selected_toggle_keys: string[];
+    }, never, {
+        ok: boolean;
+        selection: SiteProposalSelectionRecord;
+    }>;
+    createTheme: APIEndpoint<{
+        site_id: string;
+        brief?: DbJson;
+        materialized_proposal?: DbJson;
+    }, never, {
+        output: ThemeGenerationTurn[];
+        text: string[] | null;
+    }>;
+    generateThemes: APIEndpoint<{
+        site_id: string;
+    }, never, {
+        ok: boolean;
+        themes: ThemeRow[];
+    }>;
+    extractThemeFromInspiration: APIEndpoint<{
+        urls: string[];
+    }, never, {
+        palette: {
+            primary: string;
+            secondary: string;
+            accent: string;
+            background: string;
+            surface: string;
+            text: string;
+        };
+        mode: 'light' | 'dark';
+    }>;
+    saveSiteTheme: APIEndpoint<{
+        theme: Theme;
+        themeId?: string | null;
+        selectionId?: string | null;
+        overrides?: Record<string, unknown> | null;
+    }, {
+        siteId: string;
+    }, {
+        success: boolean;
+        themeId: string;
+        selectionId: string;
+        savedAt: string;
+        overrides: Record<string, unknown> | null;
+        theme: Theme;
+    }>;
+    uploadSiteLogo: APIEndpoint<FormData, never, {
+        path: string;
+        publicUrl: string | null;
+        palette: string[];
+    }>;
+    upsertThemePreferences: APIEndpoint<{
+        site_id: string;
+        has_brand_colors?: boolean;
+        brand_colors?: string[];
+        inspiration_urls?: string[];
+        logo_path?: string | null;
+        palette_variants?: Array<{
+            key: string;
+            recipe_id?: string;
+            strategy?: 'seedLocked' | 'blendLocked';
+            palette: {
+                primary: string;
+                secondary: string;
+                accent: string;
+                background: string;
+                surface: string;
+                text: string;
+            };
+        }>;
+        selected_palette_key?: string;
+        style_axes?: {
+            energy?: 'calm' | 'vibrant';
+            density?: 'airy' | 'compact';
+        };
+    }, never, {
+        ok: boolean;
+        preferences: ThemePreferencesRecord;
+    }>;
+    finalizeSite: APIEndpoint<{
+        siteId: string;
+        themeId: string;
+    }, // Body parameters
+    never, // No query parameters
+    {
+        success: boolean;
+        redirectUrl: string;
+        siteSlug: string;
+    }>;
+    getSite: APIEndpoint<never, // GET requests don't have body
+    {
+        id?: string;
+        slug?: string;
+        domain?: string;
+        scope?: 'id-only' | 'full';
+    }, // Query parameters
+    SiteBySlugResponse>;
+    getSiteBySlug: APIEndpoint<never, // GET requests don't have body
+    {
+        slug: string;
+    }, // Query parameters
+    SiteBySlugResponse>;
+    getSiteByDomain: APIEndpoint<never, // GET requests don't have body
+    {
+        domain: string;
+    }, // Query parameters
+    SiteBySlugResponse>;
+    getSiteById: APIEndpoint<never, // GET requests don't have body
+    {
+        id: string;
+    }, // Path parameters
+    SiteBySlugResponse>;
+    getBlockContent: APIEndpoint<never, // GET requests don't have body
+    {
+        blockId: string;
+    }, // Path parameters
+    BlockWithContentResponse>;
+    instagramUploadZip: APIEndpoint<FormData, undefined, {
+        ok: boolean;
+        imported: number;
+        skipped: number;
+        failed: number;
+        totalPosts: number;
+        errors: Array<{
+            uri: string;
+            error: string;
+        }>;
+    }>;
+    getAnalyticsReport: APIEndpoint<AnalyticsReportFilters, {
+        siteId: string;
+    }, AnalyticsReportResponse>;
+    getSeoOverview: APIEndpoint<never, SeoOverviewQuery, SeoOverviewResponse>;
+    getSeoPages: APIEndpoint<never, SeoSearchPagesQuery, SeoSearchPagesResponse>;
+    getSeoQueries: APIEndpoint<never, SeoSearchQueriesQuery, SeoSearchQueriesResponse>;
+    getPerformanceOverview: APIEndpoint<never, PerformanceOverviewQuery, PerformanceOverviewResponse>;
+    createMediaAsset: APIEndpoint<CreateMediaAssetBody, undefined, MediaAssetResponse>;
+    mediaList: APIEndpoint<{
+        siteId: string;
+        q?: string;
+        limit?: number;
+        offset?: number;
+        labels?: string;
+    }, never, ListMediaAssetsResult>;
+    mediaGet: APIEndpoint<never, {
+        assetId: string;
+    }, MediaAssetWithLabels>;
+    mediaUpdate: APIEndpoint<{
+        filename?: string;
+        altText?: string | null;
+        caption?: string | null;
+        width?: number | null;
+        height?: number | null;
+        durationSeconds?: number | null;
+        thumbnailAssetId?: string | null;
+        isThumbnail?: boolean;
+    }, {
+        assetId: string;
+    }, MediaAssetWithLabels>;
+    mediaDelete: APIEndpoint<{
+        deleteObject?: boolean;
+        cascadeLabels?: boolean;
+    }, {
+        assetId: string;
+    }, void>;
+    mediaBulkDelete: APIEndpoint<{
+        assetIds: string[];
+        deleteObjects?: boolean;
+        cascadeLabels?: boolean;
+    }, never, {
+        deleted: number;
+        failed: number;
+        errors?: Array<{
+            assetId: string;
+            error: string;
+        }>;
+    }>;
+    mediaGetSignedUrl: APIEndpoint<never, {
+        assetId: string;
+    }, {
+        signedUrl: string;
+    }>;
+    mediaUpload: APIEndpoint<FormData, undefined, MediaAssetWithLabels>;
+    updateBlockContent: APIEndpoint<{
+        path: string;
+        value: DbJson;
+        optimistic_hash?: string | null;
+    }, {
+        siteId: string;
+        blockId: string;
+    }, {
+        ok: boolean;
+        contentId: string;
+        version: number;
+        data: DbJson;
+        stage: 'draft' | 'published';
+        optimistic_hash?: string | null;
+    }>;
+    saveBlockContent: APIEndpoint<{
+        data: DbJson;
+        optimistic_hash?: string | null;
+    }, {
+        siteId: string;
+        blockId: string;
+    }, {
+        ok: boolean;
+        contentId: string;
+        version: number;
+        data: DbJson;
+        stage: 'draft' | 'published';
+        optimistic_hash?: string | null;
+    }>;
+    createBlock: APIEndpoint<{
+        kind: string;
+        position?: number;
+        purpose?: string;
+    }, {
+        siteId: string;
+        pageId: string;
+    }, {
+        ok: boolean;
+        block: Record<string, unknown>;
+    }>;
+    reorderBlocks: APIEndpoint<{
+        blockIds: string[];
+    }, {
+        siteId: string;
+        pageId: string;
+    }, {
+        ok: boolean;
+    }>;
+    deleteBlock: APIEndpoint<never, {
+        siteId: string;
+        pageId: string;
+        blockId: string;
+    }, {
+        ok: boolean;
+    }>;
+    listBlocks: APIEndpoint<never, {
+        siteId: string;
+        pageId: string;
+    }, {
+        blocks: BlockListItem[];
+    }>;
+    getPageById: APIEndpoint<never, {
+        siteId: string;
+        pageId: string;
+    }, {
+        page: {
+            id: string;
+            purpose: string;
+            created_at: string;
+            updated_at: string;
+            name: string;
+            path: string;
+            status: string | null;
+            draft_status: string | null;
+            published_at: string | null;
+            draft_updated_at: string | null;
+            routeId: string | null;
+            blocks: Array<Record<string, unknown>>;
+        };
+        templates?: Array<Record<string, unknown>>;
+    }>;
+    getContentByPath: APIEndpoint<{
+        path: string;
+        preview?: boolean;
+    }, {
+        siteId: string;
+    }, {
+        type?: 'page';
+        page: {
+            id: string;
+            purpose: string;
+            created_at: string;
+            updated_at: string;
+            name: string;
+            path: string;
+            status: string | null;
+            draft_status: string | null;
+            published_at: string | null;
+            draft_updated_at: string | null;
+            routeId: string | null;
+            blocks: Array<Record<string, unknown>>;
+        };
+        templates?: Array<Record<string, unknown>>;
+    } | {
+        type: 'entry';
+        entry: {
+            id: string;
+            type: string | null;
+            title: string;
+            slug: string | null;
+            status: string;
+            publishAt: string | null;
+            path: string | null;
+            draftPath: string | null;
+            content: Record<string, unknown>;
+            draftContent: Record<string, unknown> | null;
+            publishedContent: Record<string, unknown> | null;
+            metaTitle: string | null;
+            draftMetaTitle: string | null;
+            metaDescription: string | null;
+            draftMetaDescription: string | null;
+            createdAt: string;
+            updatedAt: string;
+        };
+        templates: Array<Record<string, unknown>>;
+    }>;
+    getPageByPath: APIEndpoint<never, {
+        siteId: string;
+        path: string;
+    }, {
+        page: {
+            id: string;
+            purpose: string;
+            created_at: string;
+            updated_at: string;
+            name: string;
+            path: string;
+            status: string | null;
+            draft_status: string | null;
+            published_at: string | null;
+            draft_updated_at: string | null;
+            routeId: string | null;
+            blocks: Array<Record<string, unknown>>;
+        };
+        templates?: Array<Record<string, unknown>>;
+    }>;
+    initSiteContent: APIEndpoint<{}, {
+        siteId: string;
+    }, {
+        ok: boolean;
+        created: number;
+        totalBlocks: number;
+    }>;
+    getMediaLabels: APIEndpoint<{
+        siteId: string;
+    }, never, {
+        items: MediaLabelSummary[];
+    }>;
+    getMediaSettings: APIEndpoint<{
+        siteId: string;
+    }, never, MediaSettingsResponse>;
+    updateMediaSettings: APIEndpoint<{
+        siteId: string;
+        persistVariants: boolean;
+    }, never, MediaSettingsResponse>;
+    mediaSearch: APIEndpoint<{
+        siteId: string;
+        query: string;
+        limit?: number;
+        threshold?: number;
+        labels?: string[];
+    }, never, ListMediaAssetsResult>;
+    classifyMediaAsset: APIEndpoint<{
+        force?: boolean;
+        prompt?: string;
+    }, {
+        assetId: string;
+    }, {
+        ok: boolean;
+        job: MediaClassifyJobResponse | null;
+        summary?: MediaJobSummaryResponse;
+        reason?: string;
+    }>;
+    classifyMediaBatch: APIEndpoint<{
+        siteId: string;
+        assetIds?: string[];
+        limit?: number;
+        force?: boolean;
+        prompt?: string;
+    }, never, {
+        ok: boolean;
+        job: MediaClassifyJobResponse | null;
+        summary: MediaJobSummaryResponse;
+    }>;
+    enqueueMediaClassifyJob: APIEndpoint<{
+        siteId: string;
+        assetIds?: string[];
+        limit?: number;
+        force?: boolean;
+        prompt?: string;
+    }, never, {
+        ok: boolean;
+        job: MediaClassifyJobResponse | null;
+        reason?: string;
+    }>;
+    runMediaClassifyJob: APIEndpoint<{
+        siteId: string;
+        jobId?: string;
+        maxSteps?: number;
+    }, never, {
+        ok: boolean;
+        job: MediaClassifyJobResponse | null;
+        summary?: MediaJobSummaryResponse;
+        completed?: boolean;
+        reason?: string;
+    }>;
+    runAllMediaClassifyJobs: APIEndpoint<{
+        siteIds?: string[];
+        maxSites?: number;
+        maxSteps?: number;
+    }, never, {
+        ok: boolean;
+        results: Array<{
+            siteId: string;
+            jobId: string | null;
+            status: 'skipped' | 'completed' | 'processing';
+            summary?: MediaJobSummaryResponse;
+        }>;
+    }>;
+    mediaJobsStatus: APIEndpoint<{
+        siteId: string;
+        limit?: number;
+        statuses?: string;
+    }, never, {
+        jobs: MediaClassifyJobResponse[];
+    }>;
+    devToolsImpersonateAdmin: APIEndpoint<undefined, never, DevToolsImpersonationResponse>;
+    devToolsImpersonateRandom: APIEndpoint<undefined, never, DevToolsImpersonationResponse>;
+    devToolsSeedDemoData: APIEndpoint<undefined, never, DevToolsSeedResponse>;
+    analyticsCollect: APIEndpoint<{
+        siteId?: string;
+        eventName: 'page_view' | 'cta_click' | 'form_submit';
+        path: string;
+        referrer?: string | null;
+        metadata?: Record<string, unknown>;
+        sessionId?: string;
+    }, never, {
+        ok: true;
+    }>;
+    listPublicEvents: APIEndpoint<never, {
+        siteId: string;
+        limit?: string;
+        from?: string;
+        to?: string;
+        stage?: string;
+    }, Array<{
+        id: string;
+        seriesId: string;
+        title: string;
+        description: string | null;
+        slug: string;
+        startsAt: string;
+        endsAt: string;
+        capacity: number | null;
+        registeredCount: number;
+        availableSpots: number | null;
+        venue: {
+            id: string;
+            name: string;
+            address: string | null;
+        } | null;
+    }>>;
+    registerForEvent: APIEndpoint<{
+        occurrenceId: string;
+        email: string;
+        name: string;
+        ticketsCount?: number;
+        phone?: string;
+        notes?: string;
+        formData?: Record<string, unknown>;
+    }, {
+        siteId: string;
+    }, {
+        success: boolean;
+        attendeeId: string;
+        status: 'confirmed' | 'waitlist';
+        waitlistPosition?: number;
+        message: string;
+    }>;
+    applySeoChanges: APIEndpoint<ApplySeoChangesRequest, never, ApplySeoChangesResponse>;
+    listGscPropertiesAdmin: APIEndpoint<never, never, ListGscPropertiesAdminResponse>;
+    adminSetGscPersist: APIEndpoint<AdminSetGscPersistRequest, never, AdminSetGscPersistResponse>;
+    adminStartGscVerification: APIEndpoint<AdminStartGscVerifyRequest, never, AdminStartGscVerifyResponse>;
+    adminConfirmGscVerification: APIEndpoint<AdminConfirmGscVerifyRequest, never, AdminConfirmGscVerifyResponse>;
+    adminRunGscIngest: APIEndpoint<AdminRunIngestRequest, never, AdminRunIngestResponse>;
+    getSeoVerificationMeta: APIEndpoint<never, GetSeoVerificationMetaQuery, GetSeoVerificationMetaResponse>;
+    checkRedirect: APIEndpoint<never, CheckRedirectQuery, CheckRedirectResponse>;
+    listRedirectRules: APIEndpoint<never, {
+        siteId: string;
+    }, ListRedirectRulesResponse>;
+    createRedirectRule: APIEndpoint<CreateRedirectRuleRequest, {
+        siteId: string;
+    }, CreateRedirectRuleResponse>;
+    deleteRedirectRule: APIEndpoint<never, {
+        siteId: string;
+        ruleId: string;
+    }, DeleteRedirectRuleResponse>;
+    listApiKeys: APIEndpoint<never, never, ListApiKeysResponse>;
+    createApiKey: APIEndpoint<CreateApiKeyRequest, never, CreateApiKeyResponse>;
+    revokeApiKey: APIEndpoint<never, {
+        keyId: string;
+    }, RevokeApiKeyResponse>;
+    listSiteApiKeys: APIEndpoint<never, {
+        siteId: string;
+    }, ListSiteApiKeysResponse>;
+    createSiteApiKey: APIEndpoint<CreateSiteApiKeyRequest, {
+        siteId: string;
+    }, CreateSiteApiKeyResponse>;
+    revokeSiteApiKey: APIEndpoint<never, {
+        siteId: string;
+        keyId: string;
+    }, RevokeSiteApiKeyResponse>;
+    getSitePreviewKey: APIEndpoint<never, {
+        siteId: string;
+    }, GetSitePreviewKeyResponse>;
+    regenerateSitePreviewKey: APIEndpoint<never, {
+        siteId: string;
+    }, RegenerateSitePreviewKeyResponse>;
+    getSiteApiKeyAccessLogs: APIEndpoint<never, {
+        siteId: string;
+    }, GetSiteApiKeyAccessLogsResponse>;
+    getBookingSettings: APIEndpoint<never, {
+        siteId: string;
+    }, BookingSettingsResponse>;
+    updateBookingSettings: APIEndpoint<UpdateBookingSettingsRequest, {
+        siteId: string;
+    }, BookingSettingsResponse>;
+    listAppointmentResources: APIEndpoint<never, {
+        siteId: string;
+    }, ListAppointmentResourcesResponse>;
+    createAppointmentResource: APIEndpoint<CreateAppointmentResourceRequest, {
+        siteId: string;
+    }, AppointmentResourceResponse>;
+    getAppointmentResource: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+    }, AppointmentResourceResponse>;
+    updateAppointmentResource: APIEndpoint<UpdateAppointmentResourceRequest, {
+        siteId: string;
+        resourceId: string;
+    }, AppointmentResourceResponse>;
+    deleteAppointmentResource: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+    }, DeleteResourceResponse>;
+    listAppointmentServices: APIEndpoint<never, {
+        siteId: string;
+    }, ListAppointmentServicesResponse>;
+    createAppointmentService: APIEndpoint<CreateAppointmentServiceRequest, {
+        siteId: string;
+    }, AppointmentServiceResponse>;
+    getAppointmentService: APIEndpoint<never, {
+        siteId: string;
+        serviceId: string;
+    }, AppointmentServiceResponse>;
+    updateAppointmentService: APIEndpoint<UpdateAppointmentServiceRequest, {
+        siteId: string;
+        serviceId: string;
+    }, AppointmentServiceResponse>;
+    deleteAppointmentService: APIEndpoint<never, {
+        siteId: string;
+        serviceId: string;
+    }, DeleteServiceResponse>;
+    getAppointmentServicesReference: APIEndpoint<never, {
+        siteId: string;
+    }, ReferenceOptionsResponse>;
+    getAppointmentResourcesReference: APIEndpoint<never, {
+        siteId: string;
+    }, ReferenceOptionsResponse>;
+    getResourceServices: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+    }, {
+        serviceIds: string[];
+    }>;
+    updateResourceServices: APIEndpoint<{
+        serviceIds: string[];
+    }, {
+        siteId: string;
+        resourceId: string;
+    }, {
+        success: boolean;
+        serviceIds: string[];
+    }>;
+    getServiceResources: APIEndpoint<never, {
+        siteId: string;
+        serviceId: string;
+    }, {
+        resourceIds: string[];
+    }>;
+    updateServiceResources: APIEndpoint<{
+        resourceIds: string[];
+    }, {
+        siteId: string;
+        serviceId: string;
+    }, {
+        success: boolean;
+        resourceIds: string[];
+    }>;
+    listAvailabilityRules: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+    }, ListAvailabilityRulesResponse>;
+    upsertAvailabilityRule: APIEndpoint<CreateAvailabilityRuleRequest, {
+        siteId: string;
+        resourceId: string;
+    }, UpsertAvailabilityRuleResponse>;
+    deleteAvailabilityRule: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+        ruleId: string;
+    }, DeleteAvailabilityRuleResponse>;
+    listBlackouts: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+    }, ListBlackoutsResponse>;
+    createBlackout: APIEndpoint<CreateBlackoutRequest, {
+        siteId: string;
+        resourceId: string;
+    }, CreateBlackoutResponse>;
+    deleteBlackout: APIEndpoint<never, {
+        siteId: string;
+        resourceId: string;
+        blackoutId: string;
+    }, DeleteBlackoutResponse>;
+    getAvailableSlots: APIEndpoint<GetAvailableSlotsQuery, {
+        siteId: string;
+    } & GetAvailableSlotsQuery, GetAvailableSlotsResponse>;
+    createAppointment: APIEndpoint<CreateAppointmentRequest, {
+        siteId: string;
+    }, CreateAppointmentResponse>;
+    listSiteContentTypes: APIEndpoint<never, {
+        siteId: string;
+    }, ListContentTypesResponse>;
+    getContentType: APIEndpoint<never, {
+        siteId: string;
+        typeId: string;
+    }, {
+        contentType: ContentTypeRecord;
+    }>;
+    createContentType: APIEndpoint<CreateContentTypeRequest, {
+        siteId: string;
+    }, CreateContentTypeResponse>;
+    updateContentType: APIEndpoint<UpdateContentTypeRequest, {
+        siteId: string;
+        typeId: string;
+    }, UpdateContentTypeResponse>;
+    deleteContentType: APIEndpoint<never, {
+        siteId: string;
+        typeId: string;
+    }, DeleteContentTypeResponse>;
+    duplicateContentType: APIEndpoint<{
+        newKey: string;
+    }, {
+        siteId: string;
+        typeId: string;
+    }, DuplicateContentTypeResponse>;
+    adminCreateSite: APIEndpoint<AdminCreateSiteRequest, never, AdminCreateSiteResponse>;
+    refreshSdkConfig: APIEndpoint<never, {
+        siteId: string;
+    }, RefreshSdkConfigResponse>;
+    stripeConnectAuthorize: APIEndpoint<never, {
+        siteId: string;
+    }, StripeConnectAuthorizeResponse>;
+    stripeConnectStatus: APIEndpoint<never, {
+        siteId: string;
+    }, StripeConnectStatusResponse>;
+    stripeConnectDisconnect: APIEndpoint<never, {
+        siteId: string;
+    }, StripeConnectDisconnectResponse>;
+    adminGetPriceOverride: APIEndpoint<never, AdminGetPriceOverrideQuery, AdminGetPriceOverrideResponse>;
+    adminUpsertPriceOverride: APIEndpoint<AdminUpsertPriceOverrideRequest, never, AdminUpsertPriceOverrideResponse>;
+    adminDeletePriceOverride: APIEndpoint<AdminDeletePriceOverrideRequest, never, AdminDeletePriceOverrideResponse>;
+    importSiteBackup: APIEndpoint<FormData, {
+        siteId: string;
+    }, BackupImportResponse>;
+};
+type APICallParams<E extends keyof APIEndpoints> = APIEndpoints[E] extends {
+    method: 'GET';
+} ? {
+    endpoint: E;
+    body?: APIEndpoints[E]['body'];
+    params?: APIEndpoints[E]['query'] extends Record<string, any> ? Record<keyof APIEndpoints[E]['query'], string> : Record<string, string>;
+    options?: RequestInit;
+} : APIEndpoints[E] extends {
+    method: 'POST' | 'PUT' | 'PATCH';
+} ? {
+    endpoint: E;
+    body: APIEndpoints[E]['body'];
+    params?: APIEndpoints[E]['query'] extends Record<string, any> ? Record<keyof APIEndpoints[E]['query'], string> : Record<string, string>;
+    options?: RequestInit;
+} : {
+    endpoint: E;
+    body?: APIEndpoints[E]['body'];
+    params?: APIEndpoints[E]['query'] extends Record<string, any> ? Record<keyof APIEndpoints[E]['query'], string> : Record<string, string>;
+    options?: RequestInit;
+};
+type AiPatchPageMetaOp = {
+    type: 'pageMeta';
+    set: {
+        metaTitle?: string | null;
+        metaDescription?: string | null;
+    };
+};
+type AiPatchBlockSetOp = {
+    type: 'block.set';
+    blockId: string;
+    path: string;
+    value: unknown;
+};
+type AiPatchOp = AiPatchPageMetaOp | AiPatchBlockSetOp;
+type AiPatchRequest = {
+    siteId: string;
+    pageId?: string;
+    ops: AiPatchOp[];
+};
+type AiPatchDryRunResponse = {
+    ok: true;
+    valid: boolean;
+    issues: string[];
+    ops: AiPatchOp[];
+};
+type AiPatchApplyResponse = {
+    ok: true;
+    applied: number;
+    issues: string[];
+};
+type ListGscPropertiesAdminResponse = {
+    properties: Array<{
+        id: string;
+        siteId: string;
+        siteUrl: string;
+        type: 'domain' | 'url_prefix';
+        verificationMethod: string | null;
+        verificationToken: string | null;
+        verifiedAt: string | null;
+        status: string;
+        firstSeenDate: string | null;
+        lastSyncedDate: string | null;
+        persistEnabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+type AdminSetGscPersistRequest = {
+    siteId: string;
+    enabled: boolean;
+};
+type AdminSetGscPersistResponse = {
+    ok: true;
+    meta: {
+        site_id: string;
+        persist_enabled?: boolean | null;
+        first_seen_date?: string | null;
+        last_synced_date?: string | null;
+    };
+};
+type AdminStartGscVerifyRequest = {
+    siteId: string;
+    siteUrl: string;
+};
+type AdminStartGscVerifyResponse = {
+    ok: true;
+    siteId: string;
+    siteUrl: string;
+    type: 'url_prefix';
+    token: string;
+    tag: string | null;
+};
+type AdminConfirmGscVerifyRequest = {
+    siteId: string;
+    siteUrl: string;
+};
+type AdminConfirmGscVerifyResponse = {
+    ok: boolean;
+    status?: string;
+    verifiedAt?: string;
+    message?: string;
+};
+type AdminRunIngestRequest = {
+    siteId: string;
+};
+type AdminRunIngestResponse = {
+    ok: true;
+    result: {
+        ok: true;
+        startedAt: string;
+        processed: number;
+        updatedMeta: number;
+        seededReports: number;
+        skipped: number;
+        apiRequests: number;
+        throttledMs: number;
+    };
+};
+type GetSeoVerificationMetaQuery = {
+    host?: string;
+    siteId?: string;
+};
+type GetSeoVerificationMetaResponse = {
+    ok: true;
+    token: string | null;
+};
+type SeoRangePreset = '1d' | '7d' | '30d' | '90d' | '365d';
+type SeoOverviewQuery = {
+    siteId: string;
+    preset?: SeoRangePreset;
+    start?: string;
+    end?: string;
+};
+type SeoOverviewTimePoint = {
+    date: string;
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+};
+type SeoOverviewResponse = {
+    ok: true;
+    overview: {
+        range: {
+            from: string;
+            to: string;
+            preset?: SeoRangePreset;
+        };
+        totals: {
+            clicks: number;
+            impressions: number;
+            ctr: number;
+            position: number;
+        };
+        timeseries: SeoOverviewTimePoint[];
+        lastSyncedDate: string | null;
+        persistEnabled: boolean;
+        hasData: boolean;
+    };
+    preset: SeoRangePreset;
+};
+type PerformanceRangePreset = '1d' | '7d' | '30d' | '90d' | '365d';
+type PerformanceOverviewQuery = {
+    siteId: string;
+    preset?: PerformanceRangePreset;
+    start?: string;
+    end?: string;
+};
+type PerformanceOverviewResponse = {
+    ok: true;
+    overview: {
+        range: {
+            from: string;
+            to: string;
+            preset?: PerformanceRangePreset;
+        };
+        gscConnected: boolean;
+        gscDataThrough: string | null;
+        gscPersistEnabled: boolean;
+        gscLastSyncedDate: string | null;
+        seo: {
+            totals: SeoOverviewResponse['overview']['totals'];
+            timeseries: SeoOverviewTimePoint[];
+            hasData: boolean;
+        };
+        analytics: {
+            range: AnalyticsReportResponse['range'];
+            totals: AnalyticsReportResponse['totals'];
+            series: AnalyticsReportResponse['series'];
+            topPages: AnalyticsReportResponse['topPages'];
+            topReferrers: AnalyticsReportResponse['topReferrers'];
+            goLiveAt: AnalyticsReportResponse['goLiveAt'];
+            clamped: boolean;
+            partial: boolean;
+            noDataYet: boolean;
+        };
+    };
+    preset: PerformanceRangePreset;
+};
+type SeoSearchSummary = {
+    clicks: number;
+    impressions: number;
+    ctr: number;
+    position: number;
+};
+type SeoSearchPagesQuery = {
+    siteId: string;
+    preset?: PerformanceRangePreset;
+    start?: string;
+    end?: string;
+    pageNumber?: number;
+    perPage?: number;
+    sort?: 'clicks' | 'impressions' | 'ctr' | 'position' | 'queryCount' | 'page';
+    direction?: 'asc' | 'desc';
+    search?: string;
+    page?: string;
+    device?: 'DESKTOP' | 'MOBILE' | 'TABLET';
+    country?: string;
+    format?: 'csv';
+};
+type SeoSearchPagesResponse = {
+    ok: true;
+    range: {
+        from: string;
+        to: string;
+        preset?: PerformanceRangePreset;
+    };
+    preset: PerformanceRangePreset;
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+    sort: {
+        by: NonNullable<SeoSearchPagesQuery['sort']>;
+        direction: NonNullable<SeoSearchPagesQuery['direction']>;
+    };
+    search: string | null;
+    filters: {
+        page: string | null;
+        device: SeoSearchPagesQuery['device'] | null;
+        country: string | null;
+    };
+    summary: SeoSearchSummary;
+    items: Array<{
+        page: string;
+        clicks: number;
+        impressions: number;
+        ctr: number;
+        position: number;
+        queryCount: number;
+    }>;
+};
+type SeoSearchQueriesQuery = {
+    siteId: string;
+    preset?: PerformanceRangePreset;
+    start?: string;
+    end?: string;
+    pageNumber?: number;
+    perPage?: number;
+    sort?: 'clicks' | 'impressions' | 'ctr' | 'position' | 'pageCount' | 'query';
+    direction?: 'asc' | 'desc';
+    search?: string;
+    page?: string;
+    query?: string;
+    device?: 'DESKTOP' | 'MOBILE' | 'TABLET';
+    country?: string;
+    format?: 'csv';
+};
+type SeoSearchQueriesResponse = {
+    ok: true;
+    range: {
+        from: string;
+        to: string;
+        preset?: PerformanceRangePreset;
+    };
+    preset: PerformanceRangePreset;
+    page: number;
+    perPage: number;
+    total: number;
+    totalPages: number;
+    sort: {
+        by: NonNullable<SeoSearchQueriesQuery['sort']>;
+        direction: NonNullable<SeoSearchQueriesQuery['direction']>;
+    };
+    search: string | null;
+    filters: {
+        page: string | null;
+        query: string | null;
+        device: SeoSearchQueriesQuery['device'] | null;
+        country: string | null;
+    };
+    summary: SeoSearchSummary;
+    items: Array<{
+        query: string;
+        clicks: number;
+        impressions: number;
+        ctr: number;
+        position: number;
+        pageCount: number;
+    }>;
+};
+type CheckRedirectQuery = {
+    site: string;
+    path: string;
+};
+type CheckRedirectResponse = {
+    redirectTo: string | null;
+    status?: number;
+};
+type RedirectRuleRecord = {
+    id: string;
+    siteId: string;
+    fromPath: string;
+    toPath: string;
+    httpStatus: number | null;
+    isActive: boolean;
+    createdAt?: string;
+    createdBy?: string | null;
+    updatedAt?: string;
+};
+type ListRedirectRulesResponse = {
+    redirects: RedirectRuleRecord[];
+};
+type CreateRedirectRuleRequest = {
+    fromPath: string;
+    toPath: string;
+    status?: 301 | 302 | 307 | 308;
+};
+type CreateRedirectRuleResponse = {
+    redirect: RedirectRuleRecord;
+};
+type DeleteRedirectRuleResponse = {
+    redirects: RedirectRuleRecord[];
+};
+type ApiKeyType = 'content' | 'preview';
+type ApiKeyRecord = {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    keyType: ApiKeyType;
+    createdAt: string;
+    lastUsedAt: string | null;
+    revokedAt: string | null;
+    site?: {
+        id: string;
+        title: string;
+        slug: string;
+    };
+};
+type PreviewKeyRecord = {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    createdAt: string;
+    lastUsedAt: string | null;
+};
+type ApiKeyAccessLogRecord = {
+    id: string;
+    keyId: string;
+    keyType: ApiKeyType;
+    accessedAt: string;
+    ipAddress: string | null;
+    userAgent: string | null;
+    path: string | null;
+};
+type ListApiKeysResponse = {
+    apiKeys: ApiKeyRecord[];
+};
+type CreateApiKeyRequest = {
+    siteId: string;
+    name: string;
+    environment?: 'live' | 'test';
+};
+type CreateApiKeyResponse = {
+    key: string;
+    keyId: string;
+    message: string;
+};
+type RevokeApiKeyResponse = {
+    message: string;
+};
+type ListSiteApiKeysResponse = {
+    contentKeys: ApiKeyRecord[];
+    previewKey: PreviewKeyRecord | null;
+};
+type CreateSiteApiKeyRequest = {
+    name: string;
+    environment?: 'live' | 'test';
+};
+type CreateSiteApiKeyResponse = {
+    key: string;
+    keyId: string;
+    message: string;
+};
+type RevokeSiteApiKeyResponse = {
+    message: string;
+};
+type GetSitePreviewKeyResponse = {
+    previewKey: PreviewKeyRecord | null;
+    newKey?: string;
+    message?: string;
+};
+type RegenerateSitePreviewKeyResponse = {
+    key: string;
+    keyId: string;
+    message: string;
+};
+type ApiKeyAccessLogsPagination = {
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+};
+type GetSiteApiKeyAccessLogsResponse = {
+    logs: ApiKeyAccessLogRecord[];
+    pagination: ApiKeyAccessLogsPagination;
+};
+type ContentTypeSummary = {
+    id: string;
+    siteId: string;
+    key: string;
+    name: string;
+    description: string | null;
+    hasPages: boolean;
+    routePattern: string | null;
+    isBuiltin: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+type ContentTypeRecord = ContentTypeSummary & {
+    schema: Record<string, unknown>;
+    titleField: string | null;
+};
+type CreateContentTypeRequest = {
+    key: string;
+    name: string;
+    description?: string | null;
+    schema: Record<string, unknown>;
+    titleField?: string | null;
+};
+type UpdateContentTypeRequest = {
+    name?: string;
+    description?: string | null;
+    schema?: Record<string, unknown>;
+    titleField?: string | null;
+};
+type ListContentTypesResponse = {
+    contentTypes: ContentTypeSummary[];
+};
+type CreateContentTypeResponse = {
+    contentType: ContentTypeRecord;
+};
+type UpdateContentTypeResponse = {
+    contentType: ContentTypeRecord;
+    warnings?: string[];
+};
+type DeleteContentTypeResponse = {
+    success: boolean;
+    entriesCount: number;
+    deletedAt: string;
+};
+type DuplicateContentTypeResponse = {
+    contentType: ContentTypeRecord;
+};
+type RefreshSdkConfigResponse = {
+    success: boolean;
+    config: RiverbankSiteConfig;
+};
+type StripeConnectAuthorizeResponse = {
+    authorizationUrl: string;
+    state: string;
+};
+type StripeConnectStatusResponse = {
+    isConnected: boolean;
+    stripeAccountId: string | null;
+    stripeAccountEmail: string | null;
+    onboardingComplete: boolean;
+    detailsSubmitted: boolean;
+    chargesEnabled: boolean;
+    payoutsEnabled: boolean;
+    connectedAt: string | null;
+    metadata?: Record<string, unknown> | null;
+    refreshError?: boolean;
+};
+type StripeConnectDisconnectResponse = {
+    success: boolean;
+    message: string;
+};
+type BackupImportResponse = {
+    ok: boolean;
+    siteId?: string;
+    dryRun?: boolean;
+    counts?: Record<string, {
+        created: number;
+        updated: number;
+        failed: number;
+    }>;
+    warnings?: string[];
+    errors?: Array<{
+        table: string;
+        id: string;
+        error: string;
+    }>;
+    error?: string;
+    code?: string;
+    details?: unknown;
+};
+
+type SiteResponse = NonNullable<APIEndpoints['getSite']['response']>;
+type PageResponse = NonNullable<APIEndpoints['getContentByPath']['response']>;
+type EntriesResponse = NonNullable<APIEndpoints['listPublishedEntries']['response']>;
+type EntryResponse = NonNullable<APIEndpoints['getPublishedEntryPreview']['response']>;
+type PublicFormResponse = NonNullable<APIEndpoints['getPublicFormById']['response']>;
+type PublicBookingServicesResponse = NonNullable<APIEndpoints['getPublicBookingServices']['response']>;
+type PublicEventsResponse = NonNullable<APIEndpoints['listPublicEvents']['response']>;
+/**
+ * Configuration for creating a Riverbank CMS client
+ */
+interface RiverbankClientConfig {
+    /**
+     * API key for authentication (format: bld_live_... or bld_test_...)
+     */
+    apiKey: string;
+    /**
+     * Base URL for the Riverbank CMS API (required; e.g. https://dashboard.example.com/api)
+     */
+    baseUrl: string;
+    /**
+     * Cache configuration
+     */
+    cache?: {
+        /**
+         * Enable caching (default: true)
+         */
+        enabled?: boolean;
+        /**
+         * Time-to-live for cached responses in seconds
+         * @default 300 (5 minutes)
+         */
+        ttl?: number;
+        /**
+         * Maximum number of cached responses
+         * @default 100
+         */
+        maxSize?: number;
+    };
+}
+/**
+ * Riverbank CMS client interface
+ */
+interface RiverbankClient {
+    /**
+     * Fetch site data by slug, domain, or ID
+     */
+    getSite(params: {
+        slug?: string;
+        domain?: string;
+        id?: string;
+    }): Promise<SiteResponse>;
+    /**
+     * Fetch a specific page by path
+     *
+     * @param params.preview - If true, returns draft content instead of published content (requires API key with site access)
+     */
+    getPage(params: {
+        siteId: string;
+        path: string;
+        preview?: boolean;
+    }): Promise<PageResponse>;
+    /**
+     * Fetch published content entries with optional pagination, sorting, and preview mode
+     *
+     * @param params.siteId - The site ID
+     * @param params.contentType - The content type key (e.g., 'blog-post', 'product')
+     * @param params.limit - Maximum number of entries to return
+     * @param params.order - Sort order: 'newest' (published_at desc) or 'oldest' (published_at asc)
+     * @param params.preview - If true, includes draft entries (requires API key with site access)
+     * @param params.mode - 'query' for automatic fetching, 'manual' for specific entry IDs
+     * @param params.entryIds - Array of entry IDs to fetch (only used when mode is 'manual')
+     *
+     * @example
+     * ```ts
+     * // Fetch latest 10 blog posts
+     * const entries = await client.getEntries({
+     *   siteId: 'site-id',
+     *   contentType: 'blog-post',
+     *   limit: 10,
+     *   order: 'newest',
+     * });
+     *
+     * // Fetch draft entries for preview
+     * const drafts = await client.getEntries({
+     *   siteId: 'site-id',
+     *   contentType: 'blog-post',
+     *   preview: true,
+     * });
+     *
+     * // Fetch specific entries by ID (manual mode)
+     * const specific = await client.getEntries({
+     *   siteId: 'site-id',
+     *   contentType: 'blog-post',
+     *   mode: 'manual',
+     *   entryIds: ['uuid-1', 'uuid-2'],
+     * });
+     * ```
+     */
+    getEntries(params: {
+        siteId: string;
+        contentType: string;
+        limit?: number;
+        /** Sort order for entries. 'order' uses custom ordering (default behavior). */
+        order?: 'newest' | 'oldest' | 'title' | 'order';
+        preview?: boolean;
+        /** Selection mode: 'query' for automatic, 'manual' for specific entry IDs */
+        mode?: 'query' | 'manual';
+        /** Entry IDs to fetch when mode is 'manual' */
+        entryIds?: string[];
+    }): Promise<EntriesResponse>;
+    /**
+     * Fetch a specific content entry by slug
+     */
+    getEntry(params: {
+        siteId: string;
+        contentType: string;
+        slug: string;
+    }): Promise<EntryResponse>;
+    /**
+     * Fetch a public form definition by ID
+     */
+    getPublicFormById(params: {
+        formId: string;
+    }): Promise<PublicFormResponse>;
+    /**
+     * Fetch public booking services for a site
+     */
+    getPublicBookingServices(params: {
+        siteId: string;
+        ids?: string;
+    }): Promise<PublicBookingServicesResponse>;
+    /**
+     * List public events for a site (optionally time-filtered)
+     */
+    listPublicEvents(params: {
+        siteId: string;
+        limit?: number;
+        from?: string;
+        to?: string;
+        stage?: string;
+    }): Promise<PublicEventsResponse>;
+    /**
+     * Force clear the cache
+     */
+    clearCache(): void;
+}
+
+export type { APIEndpoints as A, CustomLinkValue as C, EntriesResponse as E, HydratedTheme as H, InternalLinkValue as I, LinkValue as L, PageResponse as P, RiverbankClient as R, SiteResponse as S, Theme as T, RiverbankClientConfig as a, EntryResponse as b, APICallParams as c, SiteHeaderContent as d, SiteFooterContent as e, ExternalLinkValue as f, ExpandedPalette as g };