@dreamboard-games/api-client 0.1.0

package/dist/types.gen.d.ts

@@ -0,0 +1,5007 @@
+export type ClientOptions = {
+    baseUrl: 'https://dreamboard.games' | 'http://localhost:8080' | (string & {});
+};
+/**
+ * Backend runtime version metadata used by local development hosts.
+ */
+export type ApiVersionResponse = {
+    /**
+     * Deployed backend application revision or git SHA, when available.
+     */
+    backendRevision: string;
+    /**
+     * UI SDK version expected by the backend runtime.
+     */
+    uiSdkVersion: string;
+};
+export type GameMetadata = {
+    /**
+     * URL to the game's cover image
+     */
+    coverImage?: string;
+    /**
+     * Estimated play time
+     */
+    playTime?: '15-30 minutes' | '30-60 minutes' | '1-2 hours' | '2-3 hours' | '3+ hours';
+    /**
+     * Recommended age range
+     */
+    ageRange?: '3+' | '6+' | '8+' | '10+' | '12+' | '14+' | '16+' | '18+';
+    /**
+     * Game category or genre
+     */
+    gameCategory?: 'Abstract' | 'Strategy' | 'Eurogame' | 'Ameritrash' | 'Card Game' | 'Dice Game' | 'Party Game' | 'Cooperative' | 'Competitive' | 'Solo' | 'Family Game' | 'Wargame' | 'Tile-Placement' | 'Worker Placement' | 'Deck Builder';
+    /**
+     * Key game mechanics
+     */
+    keyMechanics?: 'Area Control' | 'Set Collection' | 'Hand Management' | 'Dice Rolling' | 'Route Building' | 'Pick-up and Deliver' | 'Auction/Bidding' | 'Hidden Roles' | 'Bluffing' | 'Push Your Luck';
+};
+/**
+ * Tracks which steps have been completed for a game
+ */
+export type CompletedSteps = {
+    /**
+     * Whether the rule has been saved
+     */
+    ruleSaved?: boolean;
+    /**
+     * Whether the manifest has been generated
+     */
+    manifestGenerated?: boolean;
+    /**
+     * Whether the app has been built
+     */
+    appBuilt?: boolean;
+    /**
+     * Whether the UI has been built
+     */
+    uiBuilt?: boolean;
+};
+/**
+ * Development status light shown in the dashboard
+ */
+export type StepLightStatus = 'yellow' | 'green' | 'red';
+/**
+ * Per-area development lights shown for a game
+ */
+export type GameCompletionLights = {
+    /**
+     * Rule authoring status light
+     */
+    rules: StepLightStatus;
+    /**
+     * Manifest authoring status light
+     */
+    manifest: StepLightStatus;
+    /**
+     * Phase logic status light
+     */
+    phases: StepLightStatus;
+    /**
+     * UI implementation status light
+     */
+    ui: StepLightStatus;
+};
+export type Game = {
+    /**
+     * Unique identifier for the game
+     */
+    id: string;
+    /**
+     * URL-safe game slug (lowercase kebab-case)
+     */
+    slug: string;
+    /**
+     * Display name of the game
+     */
+    name: string;
+    /**
+     * Detailed description of the game
+     */
+    description?: string;
+    /**
+     * Game rules text
+     */
+    ruleText?: string;
+    /**
+     * Whether the game is publicly visible
+     */
+    public: boolean;
+    /**
+     * When the game was created
+     */
+    createdAt: string;
+    /**
+     * When the game was last updated
+     */
+    updatedAt: string;
+    /**
+     * ID of the script that defines the game logic
+     */
+    scriptId?: string;
+    metadata?: GameMetadata;
+    /**
+     * Tracks which steps have been completed for this game
+     */
+    completedSteps: CompletedSteps;
+    /**
+     * Color lights representing progress since scaffold for rules, manifest, phases, and UI
+     */
+    completionLights: GameCompletionLights;
+    /**
+     * Whether the game is ready to play (all completion lights are green)
+     */
+    readyToPlay: boolean;
+    /**
+     * Whether the game has completed initial setup (all steps complete: rule saved, manifest generated, app built, UI built)
+     */
+    initialized: boolean;
+};
+/**
+ * Stable machine-readable problem identifier
+ */
+export type ProblemType = 'urn:dreamboard:problem:action-rejected' | 'urn:dreamboard:problem:active-job-conflict' | 'urn:dreamboard:problem:authoring-state-base-missing' | 'urn:dreamboard:problem:authoring-state-drift' | 'urn:dreamboard:problem:forbidden' | 'urn:dreamboard:problem:game-slug-conflict' | 'urn:dreamboard:problem:internal-error' | 'urn:dreamboard:problem:resource-not-found' | 'urn:dreamboard:problem:source-revision-base-missing' | 'urn:dreamboard:problem:source-revision-drift' | 'urn:dreamboard:problem:source-revision-not-found' | 'urn:dreamboard:problem:state-conflict' | 'urn:dreamboard:problem:too-many-requests' | 'urn:dreamboard:problem:unauthorized' | 'urn:dreamboard:problem:validation-failed';
+export type ProblemViolation = {
+    /**
+     * Optional field or input path associated with the issue
+     */
+    field?: string;
+    /**
+     * Optional machine-readable issue code
+     */
+    code?: string;
+    /**
+     * Human-readable issue description
+     */
+    message: string;
+};
+export type ProblemDetails = {
+    type: ProblemType;
+    /**
+     * Short summary of the problem type
+     */
+    title: string;
+    /**
+     * HTTP status code for this problem
+     */
+    status: number;
+    /**
+     * Human-readable explanation specific to this occurrence
+     */
+    detail: string;
+    /**
+     * Request URI or other occurrence identifier
+     */
+    instance?: string;
+    /**
+     * Correlation ID for tracing this request across logs and support tooling
+     */
+    requestId?: string;
+    /**
+     * Whether retrying the same request may succeed without changing input
+     */
+    retryable?: boolean;
+    /**
+     * Structured context for programmatic handling and richer UX
+     */
+    context?: {
+        [key: string]: string;
+    };
+    /**
+     * Optional structured issues associated with the problem
+     */
+    violations?: Array<ProblemViolation>;
+    /**
+     * ISO 8601 timestamp of the problem response
+     */
+    timestamp?: string;
+};
+/**
+ * Request to create a new game
+ */
+export type CreateGameRequest = {
+    /**
+     * URL-safe game slug (lowercase kebab-case). Optional for legacy clients.
+     */
+    slug?: string;
+    /**
+     * Name of the game (default: 'Untitled Game')
+     */
+    name?: string;
+    /**
+     * Optional description of the game
+     */
+    description?: string;
+    /**
+     * Optional initial rule text
+     */
+    ruleText?: string;
+    /**
+     * Whether to enhance the rules using AI before saving
+     */
+    enhanceRule?: boolean;
+};
+/**
+ * Request to extract a structured game spec from rule text.
+ */
+export type ExtractGameSpecRequest = {
+    ruleText: string;
+};
+/**
+ * Supported player count range for a generated game.
+ */
+export type GameSpecPlayers = {
+    min: number;
+    max: number;
+};
+/**
+ * Component family expected in the generated game.
+ */
+export type GameSpecComponent = 'deck' | 'dice' | 'board' | 'resource' | 'token' | 'tracker';
+/**
+ * A single component instance in the generated game. Multiple instances of
+ * the same `kind` are allowed (e.g. two decks). `name` is a short label and
+ * `notes` is freeform detail the agent will expand into manifest entries.
+ *
+ */
+export type GameSpecComponentSpec = {
+    kind: GameSpecComponent;
+    name: string;
+    notes?: string;
+};
+/**
+ * Structured game specification submitted by the new-game flow.
+ */
+export type GameSpecForm = {
+    name: string;
+    players: GameSpecPlayers;
+    components: Array<GameSpecComponentSpec>;
+    winCondition: string;
+    additionalRules: string;
+};
+/**
+ * Structured game spec extracted from rule text.
+ */
+export type ExtractGameSpecResponse = {
+    gameSpec: GameSpecForm;
+};
+/**
+ * Supported player-count metadata for the game
+ */
+export type PlayersDefinition = {
+    minPlayers: number;
+    maxPlayers: number;
+    optimalPlayers?: number;
+};
+export type PresetCardSetDefinition = {
+    /**
+     * Unique local identifier for the authored card set
+     */
+    id: string;
+    /**
+     * Built-in preset card-set selector
+     */
+    presetId: string;
+    /**
+     * Display name of the card set
+     */
+    name: string;
+    /**
+     * Type of card set source
+     */
+    type: 'preset';
+};
+/**
+ * Arbitrary authored JSON value.
+ */
+export type JsonValue = string | number | number | boolean | null | Array<JsonValue> | {
+    [key: string]: JsonValue;
+};
+export type PropertySchema = {
+    /**
+     * The data type of the property.
+     */
+    type: 'string' | 'integer' | 'number' | 'boolean' | 'zoneId' | 'cardId' | 'playerId' | 'boardId' | 'edgeId' | 'vertexId' | 'spaceId' | 'pieceId' | 'dieId' | 'resourceId' | 'array' | 'object' | 'record' | 'enum';
+    /**
+     * Optional description of the property's purpose and usage.
+     */
+    description?: string;
+    /**
+     * Whether an object property may be omitted.
+     */
+    optional?: boolean;
+    /**
+     * Whether the value may be null.
+     */
+    nullable?: boolean;
+    /**
+     * Optional authored default value for this property. When present, omitted
+     * seed values materialize to the default and generated TypeScript treats
+     * the property as present even if `optional: true` is also set.
+     *
+     */
+    default?: JsonValue;
+    /**
+     * For array types, the schema of the array items. Required if type is 'array'.
+     */
+    items?: PropertySchema;
+    /**
+     * For object types, the schema of the object's properties. Required if type is 'object'.
+     */
+    properties?: {
+        [key: string]: PropertySchema;
+    };
+    /**
+     * For enum types, the list of allowed string values. Required if type is 'enum'.
+     */
+    enums?: Array<string>;
+    /**
+     * For record types, the schema of the record's values. Required if type is 'record'.
+     */
+    values?: PropertySchema;
+};
+export type ObjectSchema = {
+    /**
+     * Map of property names to their schemas. Type is always 'object' and all properties are required.
+     */
+    properties: {
+        [key: string]: PropertySchema;
+    };
+};
+export type CardPropertySchemaVariants = {
+    /**
+     * Property schemas present on every card-type variant.
+     */
+    shared?: {
+        [key: string]: PropertySchema;
+    };
+    /**
+     * Property schema for each card type in this manual card set.
+     */
+    variants: {
+        [key: string]: ObjectSchema;
+    };
+};
+export type CardPropertySchema = ObjectSchema | CardPropertySchemaVariants;
+export type DetachedHomeSpec = {
+    type: 'detached';
+};
+export type ZoneHomeSpec = {
+    type: 'zone';
+    zoneId: string;
+};
+export type SpaceHomeSpec = {
+    type: 'space';
+    boardId: string;
+    spaceId: string;
+};
+export type ContainerHomeSpec = {
+    type: 'container';
+    boardId: string;
+    containerId: string;
+};
+/**
+ * Tiled board edge identified by the spaces that border it
+ */
+export type BoardEdgeRef = {
+    spaces: Array<string>;
+};
+export type EdgeHomeSpec = {
+    type: 'edge';
+    boardId: string;
+    ref: BoardEdgeRef;
+};
+/**
+ * Tiled board vertex identified by the spaces that touch it
+ */
+export type BoardVertexRef = {
+    spaces: Array<string>;
+};
+export type VertexHomeSpec = {
+    type: 'vertex';
+    boardId: string;
+    ref: BoardVertexRef;
+};
+export type PieceSlotHostRef = {
+    kind: 'piece';
+    id: string;
+};
+export type DieSlotHostRef = {
+    kind: 'die';
+    id: string;
+};
+export type SlotHostRef = ({
+    kind: 'piece';
+} & PieceSlotHostRef) | ({
+    kind: 'die';
+} & DieSlotHostRef);
+export type SlotHomeSpec = {
+    type: 'slot';
+    host: SlotHostRef;
+    slotId: string;
+};
+export type ComponentHomeSpec = ({
+    type: 'detached';
+} & DetachedHomeSpec) | ({
+    type: 'zone';
+} & ZoneHomeSpec) | ({
+    type: 'space';
+} & SpaceHomeSpec) | ({
+    type: 'container';
+} & ContainerHomeSpec) | ({
+    type: 'edge';
+} & EdgeHomeSpec) | ({
+    type: 'vertex';
+} & VertexHomeSpec) | ({
+    type: 'slot';
+} & SlotHomeSpec);
+/**
+ * Default authored visibility for a component instance
+ */
+export type ComponentVisibilitySpec = {
+    faceUp?: boolean;
+    /**
+     * When omitted, visible to all players
+     */
+    visibleTo?: Array<string>;
+};
+export type BoardCard = {
+    /**
+     * Card type identifier used to generate runtime CardIds. When count > 1, runtime IDs are generated as '{type}-1', '{type}-2', etc.
+     */
+    type: string;
+    /**
+     * Display name of the card
+     */
+    name: string;
+    /**
+     * URL to the card's image
+     */
+    imageUrl?: string;
+    /**
+     * Text content on the card
+     */
+    text?: string;
+    /**
+     * Number of copies of this card
+     */
+    count: number;
+    /**
+     * Optional authored card category or subtype identifier
+     */
+    cardType?: string;
+    /**
+     * Optional authored home for this card inventory. When omitted, cards start detached until reducer setup places them.
+     */
+    home?: ComponentHomeSpec;
+    /**
+     * Default authored visibility for the card inventory
+     */
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Actual property values for this specific card instance. Keys must match the properties defined in the referenced cardSchema.
+     */
+    properties: {
+        [key: string]: JsonValue;
+    };
+};
+export type ManualCardSetDefinition = {
+    /**
+     * Unique identifier for the card set
+     */
+    id: string;
+    /**
+     * Display name of the card set
+     */
+    name: string;
+    /**
+     * Type of card set source
+     */
+    type: 'manual';
+    /**
+     * Schema definition for authored card properties in this card set
+     */
+    cardSchema: CardPropertySchema;
+    /**
+     * List of authored cards in this card set
+     */
+    cards: Array<BoardCard>;
+};
+export type CardSetDefinition = ({
+    type: 'preset';
+} & PresetCardSetDefinition) | ({
+    type: 'manual';
+} & ManualCardSetDefinition);
+/**
+ * Whether authored topology exists once for the table or once per player
+ */
+export type TopologyScope = 'shared' | 'perPlayer';
+/**
+ * Default topology visibility for a zone or slot
+ */
+export type ZoneVisibility = 'ownerOnly' | 'public' | 'hidden';
+/**
+ * Generic authored container that can hold cards, pieces, or dice
+ */
+export type ZoneSpec = {
+    /**
+     * Stable zone identifier
+     */
+    id: string;
+    /**
+     * Display name for the zone
+     */
+    name: string;
+    scope: TopologyScope;
+    /**
+     * Optional card-set restriction for this zone
+     */
+    allowedCardSetIds?: Array<string>;
+    visibility?: ZoneVisibility;
+};
+/**
+ * Stable authored board space or slot anchor
+ */
+export type BoardSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Human-readable space name
+     */
+    name?: string;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Named relation between two authored spaces
+ */
+export type BoardRelationSpec = {
+    /**
+     * Optional stable relation identifier
+     */
+    id?: string;
+    /**
+     * Relation type identifier such as adjacent, covers, blocks, or linked
+     */
+    typeId: string;
+    fromSpaceId: string;
+    toSpaceId: string;
+    directed?: boolean;
+    /**
+     * Typed authored relation fields validated against relationFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+export type BoardHostSpec = {
+    type: 'board';
+};
+export type SpaceHostSpec = {
+    type: 'space';
+    spaceId: string;
+};
+export type BoardContainerHostSpec = ({
+    type: 'board';
+} & BoardHostSpec) | ({
+    type: 'space';
+} & SpaceHostSpec);
+/**
+ * Authored board-attached or space-attached container/slot
+ */
+export type BoardContainerSpec = {
+    /**
+     * Stable container identifier local to the board
+     */
+    id: string;
+    /**
+     * Display name for the container
+     */
+    name: string;
+    host: BoardContainerHostSpec;
+    allowedCardSetIds?: Array<string>;
+    /**
+     * Typed authored container fields validated against containerFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored board topology template
+ */
+export type GenericBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'generic';
+    /**
+     * Optional authored board type identifier such as track, map, tableau, or grid
+     */
+    typeId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    spaces?: Array<BoardSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+};
+/**
+ * Visual orientation for authored hex coordinates
+ */
+export type HexOrientation = 'pointy-top' | 'flat-top';
+/**
+ * One authored hex space in axial coordinates
+ */
+export type HexSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Axial q coordinate
+     */
+    q: number;
+    /**
+     * Axial r coordinate
+     */
+    r: number;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional hex-space label for setup or rendering
+     */
+    label?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Hex edge identified by two adjacent hex spaces
+ */
+export type HexEdgeRef = {
+    spaces: [
+        string,
+        string
+    ];
+};
+/**
+ * Authored metadata attached to one derived hex edge
+ */
+export type HexEdgeSpec = {
+    ref: HexEdgeRef;
+    /**
+     * Optional authored edge type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional edge label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored edge fields validated against edgeFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Hex vertex identified by three touching hex spaces
+ */
+export type HexVertexRef = {
+    spaces: [
+        string,
+        string,
+        string
+    ];
+};
+/**
+ * Authored metadata attached to one derived hex vertex
+ */
+export type HexVertexSpec = {
+    ref: HexVertexRef;
+    /**
+     * Optional authored vertex type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional vertex label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored vertex fields validated against vertexFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored hex board topology template
+ */
+export type HexBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'hex';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    spaces?: Array<HexSpaceSpec>;
+    edges?: Array<HexEdgeSpec>;
+    vertices?: Array<HexVertexSpec>;
+};
+/**
+ * One authored square space in row/column coordinates
+ */
+export type SquareSpaceSpec = {
+    /**
+     * Stable space identifier local to the board
+     */
+    id: string;
+    /**
+     * Zero-based row coordinate
+     */
+    row: number;
+    /**
+     * Zero-based column coordinate
+     */
+    col: number;
+    /**
+     * Optional authored space type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional square-space label for setup or rendering
+     */
+    label?: string;
+    /**
+     * Typed authored fields validated against the board's spaceFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Authored metadata attached to one derived square edge
+ */
+export type SquareEdgeSpec = {
+    ref: BoardEdgeRef;
+    /**
+     * Optional authored edge type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional edge label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored edge fields validated against edgeFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Authored metadata attached to one derived square vertex
+ */
+export type SquareVertexSpec = {
+    ref: BoardVertexRef;
+    /**
+     * Optional authored vertex type identifier
+     */
+    typeId?: string;
+    /**
+     * Optional vertex label for setup or rendering
+     */
+    label?: string;
+    tags?: Array<string>;
+    /**
+     * Typed authored vertex fields validated against vertexFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored square board topology template
+ */
+export type SquareBoardTemplateSpec = {
+    /**
+     * Stable template identifier
+     */
+    id: string;
+    name: string;
+    layout: 'square';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    spaces?: Array<SquareSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+    edges?: Array<SquareEdgeSpec>;
+    vertices?: Array<SquareVertexSpec>;
+};
+export type BoardTemplateSpec = ({
+    layout: 'generic';
+} & GenericBoardTemplateSpec) | ({
+    layout: 'hex';
+} & HexBoardTemplateSpec) | ({
+    layout: 'square';
+} & SquareBoardTemplateSpec);
+/**
+ * Shared or per-player authored board instance shell
+ */
+export type GenericBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'generic';
+    /**
+     * Optional authored board type identifier such as track, map, tableau, or grid
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<BoardSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+};
+/**
+ * Shared or per-player authored hex board instance shell
+ */
+export type HexBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'hex';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional hex board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    orientation?: HexOrientation;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<HexSpaceSpec>;
+    edges?: Array<HexEdgeSpec>;
+    vertices?: Array<HexVertexSpec>;
+};
+/**
+ * Shared or per-player authored square board instance shell
+ */
+export type SquareBoardSpec = {
+    /**
+     * Stable board identifier
+     */
+    id: string;
+    name: string;
+    layout: 'square';
+    /**
+     * Optional authored board type identifier
+     */
+    typeId?: string;
+    scope: TopologyScope;
+    /**
+     * Optional square board template to clone before applying inline authored additions
+     */
+    templateId?: string;
+    boardFieldsSchema?: ObjectSchema;
+    spaceFieldsSchema?: ObjectSchema;
+    relationFieldsSchema?: ObjectSchema;
+    containerFieldsSchema?: ObjectSchema;
+    edgeFieldsSchema?: ObjectSchema;
+    vertexFieldsSchema?: ObjectSchema;
+    /**
+     * Typed authored board fields validated against boardFieldsSchema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+    spaces?: Array<SquareSpaceSpec>;
+    relations?: Array<BoardRelationSpec>;
+    containers?: Array<BoardContainerSpec>;
+    edges?: Array<SquareEdgeSpec>;
+    vertices?: Array<SquareVertexSpec>;
+};
+export type BoardSpec = ({
+    layout: 'generic';
+} & GenericBoardSpec) | ({
+    layout: 'hex';
+} & HexBoardSpec) | ({
+    layout: 'square';
+} & SquareBoardSpec);
+/**
+ * Named authored slot exposed by a piece or die type
+ */
+export type ComponentSlotSpec = {
+    id: string;
+    name?: string;
+};
+/**
+ * Reusable authored piece type
+ */
+export type PieceTypeSpec = {
+    id: string;
+    name: string;
+    fieldsSchema?: ObjectSchema;
+    slots?: Array<ComponentSlotSpec>;
+};
+/**
+ * Authored seeded piece inventory or supply definition
+ */
+export type PieceSeedSpec = {
+    /**
+     * Stable piece id seed. When count > 1, runtime ids are generated as '{id}-1', '{id}-2', etc.
+     */
+    id?: string;
+    name?: string;
+    typeId: string;
+    count?: number;
+    ownerId?: string;
+    home?: ComponentHomeSpec;
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Typed authored piece fields validated against the piece type schema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Reusable authored die type
+ */
+export type DieTypeSpec = {
+    id: string;
+    name: string;
+    sides?: number;
+    fieldsSchema?: ObjectSchema;
+    slots?: Array<ComponentSlotSpec>;
+};
+/**
+ * Authored seeded die inventory or supply definition
+ */
+export type DieSeedSpec = {
+    /**
+     * Stable die id seed. When count > 1, runtime ids are generated as '{id}-1', '{id}-2', etc.
+     */
+    id?: string;
+    name?: string;
+    typeId: string;
+    count?: number;
+    ownerId?: string;
+    home?: ComponentHomeSpec;
+    visibility?: ComponentVisibilitySpec;
+    /**
+     * Typed authored die fields validated against the die type schema
+     */
+    fields?: {
+        [key: string]: JsonValue;
+    };
+};
+/**
+ * Definition of a game resource type
+ */
+export type ResourceDefinition = {
+    /**
+     * Unique identifier for the resource. Used as a typed ResourceId.
+     */
+    id: string;
+    /**
+     * Human-readable display name for the resource
+     */
+    name: string;
+    /**
+     * Optional compact icon or emoji rendered by generic UI resource controls.
+     */
+    icon?: string;
+};
+/**
+ * One authored setup option choice
+ */
+export type SetupOptionChoiceSpec = {
+    id: string;
+    label: string;
+    description?: string;
+};
+/**
+ * Authored setup module/variant axis metadata
+ */
+export type SetupOptionSpec = {
+    id: string;
+    name: string;
+    description?: string;
+    choices?: Array<SetupOptionChoiceSpec>;
+};
+/**
+ * Reducer-consumed authored setup profile, recipe, or loadout metadata
+ */
+export type SetupProfileSpec = {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * Selected setup-option values for this profile
+     */
+    optionValues?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Authoritative topology manifest for reducer-native games
+ */
+export type GameTopologyManifest = {
+    players: PlayersDefinition;
+    /**
+     * Authored card catalogs and schemas
+     */
+    cardSets: Array<CardSetDefinition>;
+    /**
+     * Shared and per-player authored containers
+     */
+    zones?: Array<ZoneSpec>;
+    /**
+     * Reusable board topology templates
+     */
+    boardTemplates?: Array<BoardTemplateSpec>;
+    /**
+     * Shared and per-player authored board shells
+     */
+    boards?: Array<BoardSpec>;
+    pieceTypes?: Array<PieceTypeSpec>;
+    pieceSeeds?: Array<PieceSeedSpec>;
+    dieTypes?: Array<DieTypeSpec>;
+    dieSeeds?: Array<DieSeedSpec>;
+    resources?: Array<ResourceDefinition>;
+    /**
+     * Authored setup-option metadata consumed by reducer-owned setup flows
+     */
+    setupOptions?: Array<SetupOptionSpec>;
+    /**
+     * Authored setup recipes, loadouts, or module profiles consumed by reducer setup code
+     */
+    setupProfiles?: Array<SetupProfileSpec>;
+};
+export type UpdateGameRequest = {
+    /**
+     * Updated display name
+     */
+    name?: string;
+    /**
+     * Updated description
+     */
+    description?: string;
+    /**
+     * Updated game rules text
+     */
+    rule?: string;
+    /**
+     * Updated visibility setting
+     */
+    public?: boolean;
+    manifest?: GameTopologyManifest;
+    metadata?: GameMetadata;
+};
+export type DeleteGameResponse = {
+    /**
+     * Confirms the resource was deleted
+     */
+    deleted: boolean;
+};
+export type WorkshopRuleTextResponse = {
+    /**
+     * Extracted rulebook text from the first valid candidate.
+     */
+    ruleText: string;
+};
+export type GameManifestSummaryDto = {
+    /**
+     * Unique identifier for this manifest version
+     */
+    manifestId: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created this version
+     */
+    userId: string;
+    /**
+     * Agent job that created this manifest
+     */
+    jobId?: string;
+    /**
+     * Game rule used for this manifest
+     */
+    ruleId: string;
+    /**
+     * Version number for this game
+     */
+    version: number;
+    /**
+     * Whether this is the latest/current manifest version
+     */
+    current: boolean;
+    /**
+     * When this version was created
+     */
+    createdAt: string;
+};
+export type FindManifestsResponse = {
+    /**
+     * List of manifest versions, ordered by version descending (newest first)
+     */
+    manifests: Array<GameManifestSummaryDto>;
+    /**
+     * Unique identifier of the current (latest) manifest version
+     */
+    currentManifestId?: string;
+};
+export type SaveManifestRequest = {
+    /**
+     * The board manifest to save
+     */
+    manifest: GameTopologyManifest;
+    /**
+     * Agent job that created this manifest
+     */
+    jobId?: string;
+    ruleId: string;
+};
+export type SaveManifestResponse = {
+    /**
+     * Unique identifier for the saved manifest version
+     */
+    manifestId: string;
+    /**
+     * Auto-incremented version number for this game
+     */
+    version: number;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * SHA-256 hash of the canonical manifest content, for local change detection
+     */
+    contentHash: string;
+};
+export type GameManifestDto = {
+    /**
+     * Unique identifier for this manifest version
+     */
+    manifestId: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created this version
+     */
+    userId: string;
+    /**
+     * Agent job that created this manifest
+     */
+    jobId?: string;
+    /**
+     * Game rule used for this manifest
+     */
+    ruleId: string;
+    /**
+     * The board manifest data
+     */
+    manifest: GameTopologyManifest;
+    /**
+     * Version number for this game
+     */
+    version: number;
+    /**
+     * When this version was created
+     */
+    createdAt: string;
+    /**
+     * SHA-256 hash of the canonical manifest content, for local change detection
+     */
+    contentHash: string;
+};
+/**
+ * Diagnostic severity level
+ */
+export type CompilationDiagnosticSeverity = 'error' | 'warning';
+/**
+ * Diagnostic tied to a specific project file and source location
+ */
+export type FileCompilationDiagnostic = {
+    type: 'file';
+    /**
+     * Project-relative file path where the diagnostic occurred
+     */
+    file: string;
+    /**
+     * Line number where the diagnostic occurred (1-based)
+     */
+    line: number;
+    /**
+     * Column number where the diagnostic occurred (1-based)
+     */
+    column: number;
+    /**
+     * Human-readable diagnostic message
+     */
+    message: string;
+    severity: CompilationDiagnosticSeverity;
+    /**
+     * Optional machine-readable diagnostic code (for example, a TypeScript diagnostic code)
+     */
+    code?: string;
+};
+/**
+ * Category of a project-level compilation diagnostic
+ */
+export type ProjectCompilationDiagnosticCategory = 'configuration' | 'module_resolution' | 'project' | 'system' | 'source_validation';
+/**
+ * Additional structured context for a project-level diagnostic
+ */
+export type ProjectCompilationDiagnosticContext = {
+    /**
+     * Related project-relative file path if one exists
+     */
+    file?: string;
+    /**
+     * Additional human-readable context
+     */
+    details?: string;
+    /**
+     * Module or import specifier related to the diagnostic
+     */
+    moduleName?: string;
+    /**
+     * Related project-relative paths involved in the diagnostic
+     */
+    affectedPaths?: Array<string>;
+    /**
+     * Expected scaffold SDK version when validating static scaffold inputs
+     */
+    expectedSdkVersion?: string;
+    /**
+     * Actual scaffold SDK version detected in the source snapshot
+     */
+    actualSdkVersion?: string;
+};
+/**
+ * Diagnostic that applies to the project as a whole rather than a specific source location
+ */
+export type ProjectCompilationDiagnostic = {
+    type: 'project';
+    category: ProjectCompilationDiagnosticCategory;
+    /**
+     * Human-readable diagnostic message
+     */
+    message: string;
+    severity: CompilationDiagnosticSeverity;
+    /**
+     * Optional machine-readable diagnostic code for project-level failures
+     */
+    code?: string;
+    context?: ProjectCompilationDiagnosticContext;
+};
+export type CompilationDiagnostic = ({
+    type: 'file';
+} & FileCompilationDiagnostic) | ({
+    type: 'project';
+} & ProjectCompilationDiagnostic);
+/**
+ * Storage backend type for compiled game artifacts
+ */
+export type CompiledResultStorageType = 'local' | 'supabase';
+/**
+ * Unified compiled result containing both APP and UI outputs from a single source
+ */
+export type CompiledResult = {
+    /**
+     * Compiled result identifier
+     */
+    id: string;
+    gameId: string;
+    userId: string;
+    /**
+     * Authoring state used for this compilation
+     */
+    authoringStateId: string;
+    /**
+     * Manifest used for this compilation
+     */
+    manifestId: string;
+    /**
+     * Game rule used for this compilation
+     */
+    ruleId: string;
+    /**
+     * Client- or server-generated request correlation id
+     */
+    compilationRequestId?: string;
+    /**
+     * Parent compiled result ID in the lineage graph
+     */
+    parentResultId?: string;
+    /**
+     * Root compiled result ID for this lineage
+     */
+    lineageRootId?: string;
+    /**
+     * Whether the compilation was successful
+     */
+    success: boolean;
+    /**
+     * Compilation diagnostics (only present when success=false)
+     */
+    diagnostics?: Array<CompilationDiagnostic>;
+    /**
+     * Where compiled APP (game logic) artifacts are stored
+     */
+    appStorageType: CompiledResultStorageType;
+    /**
+     * Key/path for compiled APP artifacts. Null when APP compilation fails.
+     */
+    appStorageKey?: string;
+    /**
+     * Where compiled UI (frontend) artifacts are stored
+     */
+    uiStorageType: CompiledResultStorageType;
+    /**
+     * Key/path for compiled UI artifacts. Null when UI compilation fails.
+     */
+    uiStorageKey?: string;
+    /**
+     * Deterministic fingerprint for the APP target inputs used by this compilation.
+     */
+    appFingerprint?: string;
+    /**
+     * Deterministic fingerprint for the UI target inputs used by this compilation.
+     */
+    uiFingerprint?: string;
+    /**
+     * Source revision used to produce this compilation
+     */
+    sourceRevisionId: string;
+    /**
+     * Version of the UI SDK used for this compilation
+     */
+    sdkVersion?: string;
+    createdAt: string;
+    lastModifiedAt: string;
+};
+/**
+ * Response containing a list of compiled results for a game
+ */
+export type ListCompiledResultsResponse = {
+    /**
+     * List of compiled results, sorted by creation date (newest first)
+     */
+    results: Array<CompiledResult>;
+};
+export type QueueCompiledResultJobRequest = {
+    /**
+     * Authoring state to compile
+     */
+    authoringStateId: string;
+};
+/**
+ * Accepted compile request response. The compilation continues asynchronously and can be tracked via the returned job ID.
+ */
+export type QueueCompiledResultJobResponse = {
+    /**
+     * Agent job identifier for the queued compile
+     */
+    jobId: string;
+};
+/**
+ * How the submitted change set should be applied against the base source revision.
+ */
+export type SourceChangeMode = 'incremental' | 'replace';
+/**
+ * Upsert a file in the authored source tree.
+ */
+export type SourceFileUpsert = {
+    kind: 'upsert';
+    /**
+     * Relative file path within the authored source tree.
+     */
+    path: string;
+    /**
+     * SHA-256 hash of the UTF-8 file content stored in the blob store.
+     */
+    contentHash: string;
+    /**
+     * Size of the UTF-8 file content in bytes.
+     */
+    byteSize: number;
+};
+/**
+ * Delete a file from the authored source tree.
+ */
+export type SourcePathDelete = {
+    kind: 'delete';
+    /**
+     * Relative file path within the authored source tree.
+     */
+    path: string;
+};
+export type SourceChangeOperation = ({
+    kind: 'upsert';
+} & SourceFileUpsert) | ({
+    kind: 'delete';
+} & SourcePathDelete);
+/**
+ * Request to create a new authored source revision from a change set.
+ */
+export type CreateSourceRevisionRequest = {
+    /**
+     * Base source revision the change set must apply to. Must match the current head revision when present.
+     */
+    baseSourceRevisionId?: string;
+    mode: SourceChangeMode;
+    /**
+     * Canonical change set applied to the authored source tree.
+     */
+    changes: Array<SourceChangeOperation>;
+};
+/**
+ * Request to reuse or create a private dev compilation for an exact local workspace fingerprint.
+ */
+export type EnsureDevCompileRequest = {
+    /**
+     * Client-computed deterministic fingerprint of the compile-relevant local workspace inputs.
+     */
+    devFingerprint: string;
+    /**
+     * Dreamboard environment the dev compile targets.
+     */
+    env: string;
+    sourceRevision: CreateSourceRevisionRequest;
+    /**
+     * Current local rule text for cache misses.
+     */
+    ruleText: string;
+    manifest: GameTopologyManifest;
+};
+/**
+ * Response for a fingerprint-backed dev compile ensure request.
+ */
+export type EnsureDevCompileResponse = {
+    /**
+     * Whether an existing successful dev compiled result was reused.
+     */
+    reused: boolean;
+    compiledResult?: CompiledResult;
+    /**
+     * Compile job identifier when a new dev compile was queued.
+     */
+    jobId?: string;
+    /**
+     * Private dev authoring state used for a queued compile.
+     */
+    authoringStateId?: string;
+};
+/**
+ * Response containing authored source files resolved through an authoring state.
+ */
+export type GameSourcesResponse = {
+    /**
+     * Current or requested authoring state identifier
+     */
+    authoringStateId: string;
+    /**
+     * Map of file path to file content (e.g., 'App.tsx' -> 'export ...')
+     */
+    files: {
+        [key: string]: string;
+    };
+    /**
+     * Source revision identifier used to fetch the authored source files
+     */
+    sourceRevisionId: string;
+    /**
+     * Deterministic hash of the authored source tree
+     */
+    treeHash: string;
+    /**
+     * ID of the manifest associated with this authoring state
+     */
+    manifestId?: string;
+    /**
+     * SHA-256 hash of the canonical manifest content for this authoring state
+     */
+    manifestContentHash?: string;
+    /**
+     * The board manifest data (null if no manifest is associated)
+     */
+    manifest?: GameTopologyManifest;
+    /**
+     * ID of the game rule associated with this authoring state
+     */
+    ruleId?: string;
+    /**
+     * The game rules text content (null if no rule is associated)
+     */
+    ruleText?: string;
+};
+/**
+ * Immutable authored source revision for a game.
+ */
+export type SourceRevision = {
+    /**
+     * Source revision identifier
+     */
+    id: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created the source revision
+     */
+    userId: string;
+    /**
+     * Parent source revision identifier
+     */
+    parentSourceRevisionId?: string;
+    /**
+     * Deterministic hash of the authored source tree
+     */
+    treeHash: string;
+    /**
+     * Number of authored files stored in this revision
+     */
+    fileCount: number;
+    /**
+     * Revision creation timestamp
+     */
+    createdAt: string;
+};
+/**
+ * Metadata describing a blob the client may need to upload before finalizing a source revision.
+ */
+export type SourceBlobUploadDescriptor = {
+    /**
+     * SHA-256 hash of the UTF-8 file content.
+     */
+    contentHash: string;
+    /**
+     * Size of the UTF-8 file content in bytes.
+     */
+    byteSize: number;
+};
+/**
+ * Request upload targets for one or more source blobs.
+ */
+export type CreateSourceBlobUploadSessionRequest = {
+    /**
+     * Unique blobs the client may need to upload.
+     */
+    blobs: Array<SourceBlobUploadDescriptor>;
+};
+/**
+ * Provider-agnostic direct-upload target for a source blob.
+ */
+export type SourceBlobUploadTarget = {
+    /**
+     * HTTP method the client must use when uploading the blob.
+     */
+    method: string;
+    /**
+     * Fully qualified direct-upload URL.
+     */
+    url: string;
+    /**
+     * Required request headers for the direct upload.
+     */
+    headers: {
+        [key: string]: string;
+    };
+};
+/**
+ * Upload instructions for a single source blob.
+ */
+export type SourceBlobUploadSessionEntry = {
+    /**
+     * SHA-256 hash of the UTF-8 file content.
+     */
+    contentHash: string;
+    /**
+     * Whether the blob already exists in storage or requires upload.
+     */
+    status: 'exists' | 'upload_required';
+    /**
+     * Present only when status is upload_required.
+     */
+    uploadTarget?: SourceBlobUploadTarget;
+};
+/**
+ * Direct-upload session for source blobs needed by a source revision.
+ */
+export type SourceBlobUploadSession = {
+    /**
+     * Opaque identifier for the upload session.
+     */
+    sessionId: string;
+    /**
+     * Expiration time for any issued upload targets.
+     */
+    expiresAt: string;
+    /**
+     * Upload instructions for each requested blob.
+     */
+    uploads: Array<SourceBlobUploadSessionEntry>;
+};
+/**
+ * Immutable authored workspace checkpoint tying together rule, manifest, and source revision.
+ */
+export type AuthoringState = {
+    /**
+     * Authoring state identifier
+     */
+    authoringStateId: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created this authoring state
+     */
+    userId: string;
+    /**
+     * Parent authoring state identifier
+     */
+    parentAuthoringStateId?: string;
+    /**
+     * Source revision identifier
+     */
+    sourceRevisionId: string;
+    /**
+     * Deterministic hash of the authored source tree
+     */
+    sourceTreeHash: string;
+    /**
+     * Manifest identifier
+     */
+    manifestId: string;
+    /**
+     * SHA-256 hash of the canonical manifest content
+     */
+    manifestContentHash: string;
+    /**
+     * Rule identifier
+     */
+    ruleId: string;
+    /**
+     * Authoring state creation timestamp
+     */
+    createdAt: string;
+};
+/**
+ * Advance the current authoring head to a new immutable state.
+ */
+export type CreateAuthoringStateRequest = {
+    /**
+     * Expected current authoring head before advancing. Required once a head exists.
+     */
+    baseAuthoringStateId?: string;
+    /**
+     * Source revision for the next authored state
+     */
+    sourceRevisionId: string;
+    /**
+     * Deterministic hash of the authored source tree for the next state
+     */
+    sourceTreeHash: string;
+    /**
+     * Manifest identifier for the next state
+     */
+    manifestId: string;
+    /**
+     * SHA-256 hash of the canonical manifest content for the next state
+     */
+    manifestContentHash: string;
+    /**
+     * Rule identifier for the next state
+     */
+    ruleId: string;
+};
+export type GameScriptsResponse = {
+    /**
+     * List of compiled app (game logic) scripts
+     */
+    appScripts: Array<CompiledResult>;
+    /**
+     * List of compiled UI scripts
+     */
+    uiScripts: Array<CompiledResult>;
+};
+/**
+ * Type of async backend job
+ */
+export type JobKind = 'GAME_BUILD' | 'COMPILE';
+/**
+ * Status of an async backend job
+ */
+export type JobStatus = 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' | 'INTERRUPTED';
+/**
+ * Summary information about an async backend job
+ */
+export type JobSummary = {
+    /**
+     * Unique identifier for the job
+     */
+    jobId: string;
+    /**
+     * Unique identifier for the game
+     */
+    gameId: string;
+    kind: JobKind;
+    status: JobStatus;
+    /**
+     * User-facing job title
+     */
+    title: string;
+    /**
+     * When the job was created
+     */
+    createdAt: string;
+    /**
+     * When the job started running
+     */
+    startedAt?: string;
+};
+/**
+ * Response containing the active job for a game, if any
+ */
+export type ActiveJobResponse = {
+    /**
+     * The active job, or null if no job is currently running
+     */
+    activeJob?: JobSummary;
+    /**
+     * True if there is an active job for this game
+     */
+    hasActiveJob: boolean;
+};
+/**
+ * Cache result for a specific compile target.
+ */
+export type CompileJobCacheStatus = 'hit' | 'miss';
+/**
+ * Cache reuse summary for an async compile job.
+ */
+export type CompileJobCacheSummary = {
+    app?: CompileJobCacheStatus;
+    ui?: CompileJobCacheStatus;
+};
+/**
+ * Arbitrary numeric metrics recorded for a job. Keys are implementation-defined.
+ */
+export type JobNumericMetrics = {
+    [key: string]: number;
+};
+/**
+ * Status of a user-facing job task
+ */
+export type JobTaskStatus = 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED';
+/**
+ * User-facing task progress for an async job
+ */
+export type JobTaskSummary = {
+    /**
+     * Stable task key
+     */
+    taskKey: string;
+    /**
+     * User-facing task title
+     */
+    title: string;
+    status: JobTaskStatus;
+    /**
+     * Latest high-level status for the task
+     */
+    latestStatus?: string;
+    /**
+     * Display order
+     */
+    orderIndex: number;
+    startedAt?: string;
+    completedAt?: string;
+};
+/**
+ * Detailed information for an async backend job
+ */
+export type JobDetailResponse = {
+    /**
+     * Unique identifier for the job
+     */
+    jobId: string;
+    /**
+     * Unique identifier for the game
+     */
+    gameId: string;
+    kind: JobKind;
+    status: JobStatus;
+    /**
+     * User-facing job title
+     */
+    title: string;
+    /**
+     * Error message if the job failed
+     */
+    errorMessage?: string;
+    /**
+     * When the job was created
+     */
+    createdAt: string;
+    /**
+     * When the job started running
+     */
+    startedAt?: string;
+    /**
+     * When the job completed
+     */
+    completedAt?: string;
+    /**
+     * Current compile phase for COMPILE jobs.
+     */
+    phase?: string;
+    /**
+     * Zero-based queue position for queued compile jobs, when known.
+     */
+    queuePosition?: number;
+    cache?: CompileJobCacheSummary;
+    /**
+     * User-facing status message for the current phase or terminal result.
+     */
+    message?: string;
+    timings?: JobNumericMetrics;
+    memory?: JobNumericMetrics;
+    /**
+     * Ordered user-facing task progress for this job.
+     */
+    tasks: Array<JobTaskSummary>;
+    /**
+     * Rule ID created by this job
+     */
+    createdRuleId?: string;
+    /**
+     * Manifest ID created by this job
+     */
+    createdManifestId?: string;
+    /**
+     * App script (compiled result) ID created by this job
+     */
+    createdAppScriptId?: string;
+    /**
+     * Compiled result ID created by this job
+     */
+    createdCompiledResultId?: string;
+};
+/**
+ * Request to create a Cursor Cloud game build run.
+ */
+export type CreateGameRunRequest = {
+    gameSpec: GameSpecForm;
+    ruleText?: string;
+    /**
+     * Optional pointer to a previous COMPLETED build for the same game,
+     * signaling the runner should resume that build's Cursor agent
+     * session if it is still alive. The backend validates ownership
+     * and resolves the underlying Cursor agent identifier server-side;
+     * this id is never propagated through to the runner directly.
+     *
+     */
+    parentJobId?: string;
+};
+/**
+ * Response for an accepted game build run.
+ */
+export type CreateGameRunResponse = {
+    jobId: string;
+    gameId: string;
+};
+export type GameRuleSummaryDto = {
+    /**
+     * Unique identifier for this rule version
+     */
+    ruleId: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created this version
+     */
+    userId: string;
+    /**
+     * Version number for this game's rules
+     */
+    version: number;
+    /**
+     * When this version was created
+     */
+    createdAt: string;
+    /**
+     * Preview snippet of the rule text (first 200 characters)
+     */
+    preview?: string;
+};
+export type ListGameRulesResponse = {
+    /**
+     * List of game rule versions, ordered by version descending (newest first)
+     */
+    rules: Array<GameRuleSummaryDto>;
+};
+export type CreateGameRuleRequest = {
+    /**
+     * The game rules text content
+     */
+    ruleText: string;
+};
+export type CreateGameRuleResponse = {
+    /**
+     * Unique identifier for the created rule version
+     */
+    ruleId: string;
+    /**
+     * Auto-incremented version number for this game
+     */
+    version: number;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+};
+export type GameRule = {
+    /**
+     * Unique identifier for this rule version
+     */
+    ruleId: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created this version
+     */
+    userId: string;
+    /**
+     * The game rules text content
+     */
+    ruleText: string;
+    /**
+     * Version number for this game's rules
+     */
+    version: number;
+    /**
+     * When this version was created
+     */
+    createdAt: string;
+};
+export type CreateSessionRequest = {
+    /**
+     * Compiled result ID to use for game logic and UI. If omitted, the latest successful compiled result is used.
+     */
+    compiledResultId?: string;
+    /**
+     * Optional deterministic RNG seed used when starting gameplay for this session.
+     */
+    seed?: number;
+    /**
+     * Number of players to create seats for (defaults to manifest minPlayers)
+     */
+    playerCount?: number;
+    /**
+     * If true, assign all seats to the host user (skips lobby seat assignment)
+     */
+    autoAssignSeats?: boolean;
+    /**
+     * Optional authored setup profile to apply when creating the session
+     */
+    setupProfileId?: string;
+};
+/**
+ * Authenticated Supabase user acting in a session.
+ */
+export type SessionActorAuthUser = {
+    kind: 'AUTH_USER';
+    /**
+     * auth.users id
+     */
+    id: string;
+};
+/**
+ * Anonymous demo principal for one demo_sessions row (shared across tabs).
+ */
+export type SessionActorDemoGuest = {
+    kind: 'DEMO_GUEST';
+    /**
+     * demo_sessions.id
+     */
+    demoActorSessionId: string;
+};
+export type SessionActor = ({
+    kind: 'AUTH_USER';
+} & SessionActorAuthUser) | ({
+    kind: 'DEMO_GUEST';
+} & SessionActorDemoGuest);
+export type SessionGameSourceUserCompiled = {
+    kind: 'USER_COMPILED';
+    ownerUserId: string;
+    gameId: string;
+    compiledResultId: string;
+};
+export type SessionGameSourceDemoRevision = {
+    kind: 'DEMO_REVISION';
+    slug: string;
+    revisionId: string;
+};
+export type SessionGameSource = ({
+    kind: 'USER_COMPILED';
+} & SessionGameSourceUserCompiled) | ({
+    kind: 'DEMO_REVISION';
+} & SessionGameSourceDemoRevision);
+export type CreateSessionResponse = {
+    /**
+     * Unique identifier for the created session
+     */
+    sessionId: string;
+    /**
+     * Memorable short code for sharing (e.g., 'swift-falcon-73')
+     */
+    shortCode: string;
+    hostActor: SessionActor;
+    gameSource: SessionGameSource;
+};
+/**
+ * Request to create a gameplay session by restoring a reducer-native snapshot produced by the CLI scenario harness.
+ */
+export type CreateSessionFromReducerSnapshotRequest = {
+    /**
+     * Compiled result ID that produced the reducer bundle used to create the snapshot.
+     */
+    compiledResultId: string;
+    /**
+     * Deterministic RNG seed associated with the generated base.
+     */
+    seed: number;
+    /**
+     * Number of players materialized in the reducer snapshot.
+     */
+    playerCount: number;
+    /**
+     * Authored setup profile associated with the generated base, if any.
+     */
+    setupProfileId?: string;
+    /**
+     * Generated base artifact id used to hydrate the reducer shadow.
+     */
+    baseId: string;
+    /**
+     * Scenario id materialized into this session.
+     */
+    scenarioId: string;
+    /**
+     * Final reducer-native session state after running scenario.when locally.
+     */
+    reducerState: {
+        [key: string]: unknown;
+    };
+    /**
+     * Reducer runtime version corresponding to reducerState.
+     */
+    reducerStateVersion: number;
+    /**
+     * CLI-computed fingerprint diagnostics for the generated base and scenario materialization.
+     */
+    fingerprintMetadata?: {
+        [key: string]: string;
+    };
+};
+export type SessionSnapshotPhase = 'lobby' | 'gameplay' | 'ended';
+export type HostSessionStatus = 'active' | 'ended';
+/**
+ * Summary of a game state history entry.
+ */
+export type HistoryEntrySummary = {
+    id: string;
+    version: number;
+    timestamp: string;
+    description: string;
+    playerId?: string;
+    actionType?: string;
+    isCurrent: boolean;
+};
+export type SessionSnapshotHistory = {
+    entries: Array<HistoryEntrySummary>;
+    currentIndex: number;
+    canGoBack: boolean;
+    canGoForward: boolean;
+};
+export type HostSessionContext = {
+    /**
+     * Unique identifier for the session.
+     */
+    sessionId: string;
+    /**
+     * Memorable short code for sharing.
+     */
+    shortCode: string;
+    phase: SessionSnapshotPhase;
+    status: HostSessionStatus;
+    hostActor: SessionActor;
+    gameSource: SessionGameSource;
+    /**
+     * Selected authored setup profile for this session.
+     */
+    setupProfileId?: string;
+    /**
+     * Player IDs the authenticated session actor may select.
+     */
+    switchablePlayerIds: Array<string>;
+    history?: SessionSnapshotHistory;
+};
+export type SeatAssignment = {
+    /**
+     * Player identifier (e.g., 'player-1')
+     */
+    playerId: string;
+    /**
+     * Session actor controlling this seat (null if empty)
+     */
+    controllerActor?: SessionActor;
+    /**
+     * Display name for this seat/player
+     */
+    displayName: string;
+    /**
+     * Hex color code for the player (e.g., '#FF5733')
+     */
+    playerColor?: string;
+    /**
+     * Whether this seat is the host
+     */
+    isHost?: boolean;
+};
+export type HostLobbyView = {
+    /**
+     * Current public seat assignments for the session.
+     */
+    seats: Array<SeatAssignment>;
+    /**
+     * Whether the lobby can currently be started.
+     */
+    canStart: boolean;
+    /**
+     * Session actor that hosts this session.
+     */
+    hostActor: SessionActor;
+    /**
+     * Selected authored setup profile for this session.
+     */
+    setupProfileId?: string;
+};
+export type HostLobbySessionSnapshot = {
+    type: 'lobby';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+export type SimultaneousPhaseSnapshot = {
+    phaseName: string;
+    interactionId: string;
+    actorIds: Array<string>;
+    sealedPlayerIds: Array<string>;
+    pendingPlayerIds: Array<string>;
+};
+/**
+ * Draft commit policy consumed by default UI surfaces.
+ */
+export type InteractionCommitPolicy = {
+    mode: 'manual' | 'autoWhenReady';
+};
+export type ResourceMapDomainEntry = {
+    resourceId: string;
+    label?: string;
+    icon?: string;
+    min: number;
+    max: number;
+};
+export type ChoiceDomainOption = {
+    value: string;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+/**
+ * Selection cardinality for an input domain.
+ */
+export type InputSelection = {
+    mode: 'single' | 'many';
+    min?: number;
+    max?: number;
+    distinct?: boolean;
+};
+export type InputDomain = {
+    type: 'target' | 'resourceMap' | 'boundedNumber' | 'choice' | 'choiceList';
+    targetKind?: string;
+    boardId?: string;
+    zoneId?: string;
+    zoneIds?: Array<string>;
+    eligibleTargets?: Array<string>;
+    resources?: Array<ResourceMapDomainEntry>;
+    min?: number;
+    max?: number;
+    step?: number;
+    choices?: Array<ChoiceDomainOption>;
+    selection?: InputSelection;
+};
+/**
+ * Canonical descriptor for one interaction input collector.
+ */
+export type InteractionInputDescriptor = {
+    key: string;
+    kind: string;
+    domain: InputDomain;
+    /**
+     * Optional default value applied to this input when the player has not
+     * yet drafted a value. Mirrors the input collector's `defaultValue`
+     * from the authored interaction, so plugins can render a sensible
+     * starting state (e.g. a pre-selected resource for a bank trade).
+     *
+     */
+    defaultValue?: JsonValue;
+};
+export type InteractionContextOption = {
+    id: string;
+    label: string;
+};
+export type InteractionContext = {
+    to: string;
+    title?: string;
+    payload?: {
+        [key: string]: JsonValue;
+    };
+    options?: Array<InteractionContextOption>;
+};
+/**
+ * Authoritative interaction descriptor resolved by the trusted bundle.
+ */
+export type InteractionDescriptor = {
+    phaseName: string;
+    interactionKey: string;
+    interactionId: string;
+    kind: 'action' | 'prompt';
+    zoneId?: string;
+    /**
+     * Draft commit policy materialized by the trusted reducer bundle. Omitted authoring specs default to manual before this descriptor crosses the runtime boundary.
+     */
+    commit: InteractionCommitPolicy;
+    /**
+     * Ordered input descriptors. Each entry is the canonical source for its collector key, collector kind, and valid-value domain.
+     */
+    inputs: Array<InteractionInputDescriptor>;
+    cost?: {
+        [key: string]: JsonValue;
+    };
+    currentResources?: {
+        [key: string]: JsonValue;
+    };
+    /**
+     * Resource shortfall by resource id when a costed interaction is not currently affordable.
+     */
+    missingResources?: {
+        [key: string]: number;
+    };
+    available: boolean;
+    unavailableReason?: string;
+    context?: InteractionContext;
+};
+export type ZoneHandles = {
+    cardIds: Array<string>;
+    cardsById: {
+        [key: string]: string;
+    };
+    playableByCardId: {
+        [key: string]: Array<InteractionDescriptor>;
+    };
+};
+export type HostPlayerGameplayView = {
+    /**
+     * Monotonic gameplay version for stale-client detection.
+     */
+    version: number;
+    /**
+     * Opaque revision token for the selected player's current descriptors and input domains.
+     */
+    actionSetVersion: string;
+    /**
+     * Player ID this gameplay snapshot is scoped to.
+     */
+    playerId: string;
+    /**
+     * Player IDs currently active in the game state.
+     */
+    activePlayers: Array<string>;
+    /**
+     * Current reducer-native gameplay phase.
+     */
+    currentPhase: string;
+    /**
+     * Current stage within the phase. Null when the phase has no active stage.
+     */
+    currentStage: string;
+    /**
+     * Player IDs this stage currently admits.
+     */
+    stageSeats: Array<string>;
+    /**
+     * Visibility-safe progress metadata for an active simultaneous-player phase.
+     */
+    simultaneousPhase?: SimultaneousPhaseSnapshot;
+    /**
+     * JSON-serialized reducer-projected UI view for the scoped player.
+     */
+    view: string;
+    /**
+     * Interaction descriptors for the scoped player, resolved authoritatively by the trusted bundle.
+     */
+    availableInteractions: Array<InteractionDescriptor>;
+    /**
+     * Zone handles for the scoped player, keyed by zone id.
+     */
+    zones: {
+        [key: string]: ZoneHandles;
+    };
+    /**
+     * JSON-serialized session-scoped static view. Populated on gameplay bootstrap payloads only.
+     */
+    boardStatic?: string;
+    /**
+     * Content hash of the session-scoped static view held on the host.
+     */
+    boardStaticHash?: string;
+};
+export type HostGameplaySessionSnapshot = {
+    type: 'gameplay';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+    gameplay: HostPlayerGameplayView;
+};
+export type HostEndedSessionSnapshot = {
+    type: 'ended';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+export type HostSessionSnapshot = ({
+    type: 'lobby';
+} & HostLobbySessionSnapshot) | ({
+    type: 'gameplay';
+} & HostGameplaySessionSnapshot) | ({
+    type: 'ended';
+} & HostEndedSessionSnapshot);
+export type HostSessionSnapshotReason = 'load' | 'start' | 'switch-player' | 'resync';
+export type HostSessionSnapshotEvent = {
+    type: 'session.snapshot';
+    reason: HostSessionSnapshotReason;
+    snapshot: HostSessionSnapshot;
+};
+export type HostSessionLobbyUpdatedEvent = {
+    type: 'session.lobbyUpdated';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+export type HostSessionEventCausation = {
+    clientActionId?: string;
+};
+export type HostSessionGameplayUpdatedEvent = {
+    type: 'session.gameplayUpdated';
+    context: HostSessionContext;
+    gameplay: HostPlayerGameplayView;
+    causation?: HostSessionEventCausation;
+};
+export type HostSessionHistoryUpdatedEvent = {
+    type: 'session.historyUpdated';
+    context: HostSessionContext;
+};
+export type HostSessionEndedEvent = {
+    type: 'session.ended';
+    context: HostSessionContext;
+    lobby: HostLobbyView;
+};
+export type HostSessionErrorEvent = {
+    type: 'session.error';
+    sessionId: string;
+    code?: string;
+    message: string;
+    recoverable: boolean;
+};
+export type HostSessionEvent = ({
+    type: 'session.snapshot';
+} & HostSessionSnapshotEvent) | ({
+    type: 'session.lobbyUpdated';
+} & HostSessionLobbyUpdatedEvent) | ({
+    type: 'session.gameplayUpdated';
+} & HostSessionGameplayUpdatedEvent) | ({
+    type: 'session.historyUpdated';
+} & HostSessionHistoryUpdatedEvent) | ({
+    type: 'session.ended';
+} & HostSessionEndedEvent) | ({
+    type: 'session.error';
+} & HostSessionErrorEvent);
+/**
+ * Log entry from the game engine console output
+ */
+export type LogMessageDto = {
+    /**
+     * Unique identifier for the log entry
+     */
+    id: number;
+    /**
+     * Type of log entry
+     */
+    type: string;
+    /**
+     * The log message content
+     */
+    message: string;
+    /**
+     * When the log was recorded
+     */
+    timestamp: string;
+};
+export type PlayerActionsResponse = {
+    version: number;
+    actionSetVersion: string;
+    actions: Array<InteractionDescriptor>;
+};
+export type PlayerActionResponse = {
+    version: number;
+    actionSetVersion: string;
+    action: InteractionDescriptor;
+};
+export type PlayerActionTargetsResponse = {
+    version: number;
+    actionSetVersion: string;
+    interactionId: string;
+    inputKey: string;
+    domain: InputDomain;
+    zoneCardsById?: {
+        [key: string]: string;
+    };
+};
+export type PlayerActionRequest = {
+    expectedVersion: number;
+    actionSetVersion: string;
+    inputs: {
+        [key: string]: JsonValue;
+    };
+};
+export type PlayerActionValidateResponse = {
+    valid: boolean;
+    version: number;
+    actionSetVersion: string;
+    errorCode?: string;
+    message?: string;
+    fieldErrors?: {
+        [key: string]: string;
+    };
+};
+export type HostActionSubmitResponse = {
+    success: boolean;
+    version: number;
+    actionSetVersion: string;
+    accepted?: boolean;
+    errorCode?: string;
+    message?: string;
+    event?: HostSessionEvent;
+};
+/**
+ * Request to update seat settings (display name and/or player color)
+ */
+export type UpdateSeatRequest = {
+    /**
+     * New display name for the player
+     */
+    displayName?: string;
+    /**
+     * Hex color code for the player (e.g., '#FF5733')
+     */
+    playerColor?: string;
+};
+/**
+ * Request to restore game state to a previous history point.
+ */
+export type RestoreHistoryRequest = {
+    entryId: string;
+};
+export type RestoreHistoryResponse = {
+    success: boolean;
+    restoredToVersion: number;
+    message?: string;
+};
+/**
+ * Public demo game summary.
+ */
+export type DemoGameSummary = {
+    slug: string;
+    name: string;
+    description?: string;
+    /**
+     * Short public overview shown before starting the demo.
+     */
+    overview?: string;
+    /**
+     * Relative URL for the bundled static demo thumbnail.
+     */
+    thumbnailUrl?: string;
+    /**
+     * Public creator or publisher attribution shown in the demo dialog.
+     */
+    creator?: string;
+    /**
+     * Minimum supported player count for the demo game.
+     */
+    minPlayers?: number;
+    /**
+     * Maximum supported player count for the demo game.
+     */
+    maxPlayers?: number;
+    /**
+     * Lower bound for the expected play time.
+     */
+    playTimeMinMinutes?: number;
+    /**
+     * Upper bound for the expected play time.
+     */
+    playTimeMaxMinutes?: number;
+    /**
+     * Lightweight public difficulty rating on a 1-5 scale.
+     */
+    difficulty?: number;
+    /**
+     * Public mechanics shown as chips in the demo dialog.
+     */
+    mechanics?: Array<string>;
+    /**
+     * Public categories shown as chips in the demo dialog.
+     */
+    categories?: Array<string>;
+    /**
+     * Public hero image URL for the demo dialog.
+     */
+    heroImageUrl?: string;
+    /**
+     * Approximate time needed to try the local demo.
+     */
+    estimatedMinutes?: number;
+    /**
+     * Number of player seats shown for the local teaching demo.
+     */
+    demoPlayerCount: number;
+    registrationStatus: 'PENDING' | 'REGISTERING' | 'REGISTERED' | 'FAILED';
+    playable: boolean;
+};
+export type DemoGameDetails = DemoGameSummary & {
+    /**
+     * Active immutable catalog revision when registered.
+     */
+    activeRevisionId?: string;
+    bundleFingerprint?: string;
+    error?: string;
+};
+/**
+ * Guest-play session created for a public demo game.
+ */
+export type DemoSessionResponse = {
+    /**
+     * game_sessions.session_id
+     */
+    sessionId: string;
+    shortCode: string;
+    /**
+     * demo_sessions.id; send with demo session secret headers to authorize as DemoGuest.
+     */
+    demoActorSessionId: string;
+    /**
+     * Per-session secret; send with demo headers (hashed server-side).
+     */
+    guestSessionSecret: string;
+    seed: number;
+    selectedPlayerId?: string;
+    gameSource: SessionGameSource;
+};
+export type HistoryUpdatedEvent = {
+    type: 'history.updated';
+    history: SessionSnapshotHistory;
+};
+/**
+ * Type of parameter accepted by a runtime action
+ */
+export type ParameterType = 'cardId' | 'cardType' | 'playerId' | 'string' | 'number' | 'boolean' | 'zoneId' | 'pieceId' | 'dieId' | 'boardId' | 'edgeId' | 'vertexId' | 'spaceId' | 'resourceId';
+/**
+ * Defines a parameter for an action
+ */
+export type ActionParameterDefinition = {
+    name: string;
+    type: ParameterType;
+    required?: boolean;
+    array?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    /**
+     * Optional card set ID to specify which card set a CARD_ID parameter refers to
+     */
+    cardSetId?: string;
+    description?: string;
+};
+/**
+ * Defines an available player action with metadata and parameter definitions
+ */
+export type ActionDefinition = {
+    /**
+     * Unique action identifier
+     */
+    actionType: string;
+    /**
+     * UI display name for this action
+     */
+    displayName: string;
+    /**
+     * Optional help text describing the action
+     */
+    description?: string;
+    /**
+     * List of parameters this action accepts
+     */
+    parameters: Array<ActionParameterDefinition>;
+    /**
+     * List of possible validation error codes
+     */
+    errorCodes?: Array<string>;
+};
+/**
+ * Type of source for the card set
+ */
+export type CardSetSourceType = 'preset' | 'csv' | 'manual';
+/**
+ * Engine-level structural board layout discriminator
+ */
+export type BoardLayout = 'generic' | 'hex' | 'square';
+export type GameManifestResponse = {
+    /**
+     * Unique identifier for this manifest version
+     */
+    manifestId: string;
+    /**
+     * Game identifier
+     */
+    gameId: string;
+    /**
+     * User who created this version
+     */
+    userId: string;
+    /**
+     * Agent job that created this manifest
+     */
+    jobId?: string;
+    /**
+     * The board manifest data
+     */
+    manifest: GameTopologyManifest;
+    /**
+     * Version number for this game
+     */
+    version: number;
+    /**
+     * When this version was created
+     */
+    createdAt: string;
+};
+/**
+ * Unique identifier for the game
+ */
+export type GameId = string;
+/**
+ * URL-safe game slug
+ */
+export type GameSlug = string;
+/**
+ * Unique identifier for the game session
+ */
+export type SessionId = string;
+/**
+ * Unique identifier for the player (e.g., 'player-1')
+ */
+export type PlayerId = string;
+export type HealthCheckData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/';
+};
+export type HealthCheckResponses = {
+    /**
+     * Service is healthy
+     */
+    200: string;
+};
+export type HealthCheckResponse = HealthCheckResponses[keyof HealthCheckResponses];
+export type GetApiVersionData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/version';
+};
+export type GetApiVersionResponses = {
+    /**
+     * Successfully retrieved backend version metadata
+     */
+    200: ApiVersionResponse;
+};
+export type GetApiVersionResponse = GetApiVersionResponses[keyof GetApiVersionResponses];
+export type ListGamesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Include games that haven't been fully initialized (missing rules, manifest, app, or UI). Defaults to false.
+         */
+        includeNotInitialized?: boolean;
+    };
+    url: '/api/games';
+};
+export type ListGamesErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type ListGamesError = ListGamesErrors[keyof ListGamesErrors];
+export type ListGamesResponses = {
+    /**
+     * Successfully retrieved games list
+     */
+    200: Array<Game>;
+};
+export type ListGamesResponse = ListGamesResponses[keyof ListGamesResponses];
+export type CreateGameData = {
+    body: CreateGameRequest;
+    path?: never;
+    query?: never;
+    url: '/api/games';
+};
+export type CreateGameErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Conflict - version mismatch or resource state conflict
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateGameError = CreateGameErrors[keyof CreateGameErrors];
+export type CreateGameResponses = {
+    /**
+     * Game created successfully
+     */
+    201: Game;
+};
+export type CreateGameResponse = CreateGameResponses[keyof CreateGameResponses];
+export type ExtractGameSpecData = {
+    body: ExtractGameSpecRequest;
+    path?: never;
+    query?: never;
+    url: '/api/games/extract-spec';
+};
+export type ExtractGameSpecErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Too many requests or live connections
+     */
+    429: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    503: ProblemDetails;
+};
+export type ExtractGameSpecError = ExtractGameSpecErrors[keyof ExtractGameSpecErrors];
+export type ExtractGameSpecResponses = {
+    /**
+     * Structured game spec extracted
+     */
+    200: ExtractGameSpecResponse;
+};
+export type ExtractGameSpecResponse2 = ExtractGameSpecResponses[keyof ExtractGameSpecResponses];
+export type DeleteGameData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}';
+};
+export type DeleteGameErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type DeleteGameError = DeleteGameErrors[keyof DeleteGameErrors];
+export type DeleteGameResponses = {
+    /**
+     * Game deleted successfully
+     */
+    200: DeleteGameResponse;
+};
+export type DeleteGameResponse2 = DeleteGameResponses[keyof DeleteGameResponses];
+export type GetGameData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}';
+};
+export type GetGameErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetGameError = GetGameErrors[keyof GetGameErrors];
+export type GetGameResponses = {
+    /**
+     * Successfully retrieved game
+     */
+    200: Game;
+};
+export type GetGameResponse = GetGameResponses[keyof GetGameResponses];
+export type UpdateGameData = {
+    body: UpdateGameRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}';
+};
+export type UpdateGameErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type UpdateGameError = UpdateGameErrors[keyof UpdateGameErrors];
+export type UpdateGameResponses = {
+    /**
+     * Success message
+     */
+    200: string;
+};
+export type UpdateGameResponse = UpdateGameResponses[keyof UpdateGameResponses];
+export type GetGameBySlugData = {
+    body?: never;
+    path: {
+        /**
+         * URL-safe game slug
+         */
+        slug: string;
+    };
+    query?: {
+        /**
+         * Include soft-deleted games in the lookup. Defaults to false.
+         */
+        includeDeleted?: boolean;
+    };
+    url: '/api/games/slug/{slug}';
+};
+export type GetGameBySlugErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetGameBySlugError = GetGameBySlugErrors[keyof GetGameBySlugErrors];
+export type GetGameBySlugResponses = {
+    /**
+     * Successfully retrieved game
+     */
+    200: Game;
+};
+export type GetGameBySlugResponse = GetGameBySlugResponses[keyof GetGameBySlugResponses];
+export type QueryWorkshopRulebookData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Board game title to search for in the rulebook library.
+         */
+        title: string;
+    };
+    url: '/api/workshop/query';
+};
+export type QueryWorkshopRulebookErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type QueryWorkshopRulebookError = QueryWorkshopRulebookErrors[keyof QueryWorkshopRulebookErrors];
+export type QueryWorkshopRulebookResponses = {
+    /**
+     * Extracted rulebook text for the first valid candidate.
+     */
+    200: WorkshopRuleTextResponse;
+};
+export type QueryWorkshopRulebookResponse = QueryWorkshopRulebookResponses[keyof QueryWorkshopRulebookResponses];
+export type FindManifestsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query: {
+        /**
+         * Maximum number of manifests to return (default: 10, max: 100)
+         */
+        limit?: number;
+        /**
+         * Filter to only return manifests for a specific rule
+         */
+        ruleId: string;
+    };
+    url: '/api/games/{gameId}/manifests';
+};
+export type FindManifestsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type FindManifestsError = FindManifestsErrors[keyof FindManifestsErrors];
+export type FindManifestsResponses = {
+    /**
+     * Manifests retrieved successfully
+     */
+    200: FindManifestsResponse;
+};
+export type FindManifestsResponse2 = FindManifestsResponses[keyof FindManifestsResponses];
+export type SaveManifestData = {
+    body: SaveManifestRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/manifests';
+};
+export type SaveManifestErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type SaveManifestError = SaveManifestErrors[keyof SaveManifestErrors];
+export type SaveManifestResponses = {
+    /**
+     * Manifest saved successfully
+     */
+    201: SaveManifestResponse;
+};
+export type SaveManifestResponse2 = SaveManifestResponses[keyof SaveManifestResponses];
+export type GetManifestData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the manifest
+         */
+        manifestId: string;
+    };
+    query?: never;
+    url: '/api/manifests/{manifestId}';
+};
+export type GetManifestErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetManifestError = GetManifestErrors[keyof GetManifestErrors];
+export type GetManifestResponses = {
+    /**
+     * Manifest retrieved successfully
+     */
+    200: GameManifestDto;
+};
+export type GetManifestResponse = GetManifestResponses[keyof GetManifestResponses];
+export type GetLatestCompiledResultData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: {
+        /**
+         * If true, only return results where success=true and uiStorageKey is present
+         */
+        successOnly?: boolean;
+    };
+    url: '/api/games/{gameId}/compiled-results/latest';
+};
+export type GetLatestCompiledResultErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetLatestCompiledResultError = GetLatestCompiledResultErrors[keyof GetLatestCompiledResultErrors];
+export type GetLatestCompiledResultResponses = {
+    /**
+     * Latest compiled result found
+     */
+    200: CompiledResult;
+};
+export type GetLatestCompiledResultResponse = GetLatestCompiledResultResponses[keyof GetLatestCompiledResultResponses];
+export type ListCompiledResultsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: {
+        /**
+         * Maximum number of results to return. Default is 10.
+         */
+        limit?: number;
+        /**
+         * Optional authoring state ID to limit results to a single authored head.
+         */
+        authoringStateId?: string;
+    };
+    url: '/api/games/{gameId}/compiled-results';
+};
+export type ListCompiledResultsErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type ListCompiledResultsError = ListCompiledResultsErrors[keyof ListCompiledResultsErrors];
+export type ListCompiledResultsResponses = {
+    /**
+     * Compiled results retrieved successfully
+     */
+    200: ListCompiledResultsResponse;
+};
+export type ListCompiledResultsResponse2 = ListCompiledResultsResponses[keyof ListCompiledResultsResponses];
+export type QueueCompiledResultJobData = {
+    body: QueueCompiledResultJobRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/compiled-results';
+};
+export type QueueCompiledResultJobErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type QueueCompiledResultJobError = QueueCompiledResultJobErrors[keyof QueueCompiledResultJobErrors];
+export type QueueCompiledResultJobResponses = {
+    /**
+     * Compile job accepted
+     */
+    202: QueueCompiledResultJobResponse;
+};
+export type QueueCompiledResultJobResponse2 = QueueCompiledResultJobResponses[keyof QueueCompiledResultJobResponses];
+export type EnsureDevCompileData = {
+    body: EnsureDevCompileRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/dev-compiles/ensure';
+};
+export type EnsureDevCompileErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Conflict - version mismatch or resource state conflict
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type EnsureDevCompileError = EnsureDevCompileErrors[keyof EnsureDevCompileErrors];
+export type EnsureDevCompileResponses = {
+    /**
+     * Existing dev compile reused or cache miss reported
+     */
+    200: EnsureDevCompileResponse;
+    /**
+     * Dev compile job accepted
+     */
+    202: EnsureDevCompileResponse;
+};
+export type EnsureDevCompileResponse2 = EnsureDevCompileResponses[keyof EnsureDevCompileResponses];
+export type GetCompiledResultData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+        /**
+         * Unique identifier for the compiled result
+         */
+        compiledResultId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/compiled-results/{compiledResultId}';
+};
+export type GetCompiledResultErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetCompiledResultError = GetCompiledResultErrors[keyof GetCompiledResultErrors];
+export type GetCompiledResultResponses = {
+    /**
+     * Compiled result found
+     */
+    200: CompiledResult;
+};
+export type GetCompiledResultResponse = GetCompiledResultResponses[keyof GetCompiledResultResponses];
+export type DownloadGameSourcesData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/download';
+};
+export type DownloadGameSourcesErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type DownloadGameSourcesError = DownloadGameSourcesErrors[keyof DownloadGameSourcesErrors];
+export type DownloadGameSourcesResponses = {
+    /**
+     * ZIP archive containing source files
+     */
+    200: Blob | File;
+};
+export type DownloadGameSourcesResponse = DownloadGameSourcesResponses[keyof DownloadGameSourcesResponses];
+export type GetGameSourcesData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: {
+        /**
+         * Optional authoring state ID to fetch sources from. If not provided, uses the current authoring head.
+         */
+        authoringStateId?: string;
+    };
+    url: '/api/games/{gameId}/sources';
+};
+export type GetGameSourcesErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetGameSourcesError = GetGameSourcesErrors[keyof GetGameSourcesErrors];
+export type GetGameSourcesResponses = {
+    /**
+     * Source files retrieved successfully
+     */
+    200: GameSourcesResponse;
+};
+export type GetGameSourcesResponse = GetGameSourcesResponses[keyof GetGameSourcesResponses];
+export type CreateSourceRevisionData = {
+    body: CreateSourceRevisionRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/source-revisions';
+};
+export type CreateSourceRevisionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Base source revision does not match the current head revision
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateSourceRevisionError = CreateSourceRevisionErrors[keyof CreateSourceRevisionErrors];
+export type CreateSourceRevisionResponses = {
+    /**
+     * Source revision created
+     */
+    201: SourceRevision;
+};
+export type CreateSourceRevisionResponse = CreateSourceRevisionResponses[keyof CreateSourceRevisionResponses];
+export type CreateSourceBlobUploadSessionData = {
+    body: CreateSourceBlobUploadSessionRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/source-blobs/upload-sessions';
+};
+export type CreateSourceBlobUploadSessionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateSourceBlobUploadSessionError = CreateSourceBlobUploadSessionErrors[keyof CreateSourceBlobUploadSessionErrors];
+export type CreateSourceBlobUploadSessionResponses = {
+    /**
+     * Upload session created
+     */
+    201: SourceBlobUploadSession;
+};
+export type CreateSourceBlobUploadSessionResponse = CreateSourceBlobUploadSessionResponses[keyof CreateSourceBlobUploadSessionResponses];
+export type GetAuthoringHeadData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/authoring/head';
+};
+export type GetAuthoringHeadErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetAuthoringHeadError = GetAuthoringHeadErrors[keyof GetAuthoringHeadErrors];
+export type GetAuthoringHeadResponses = {
+    /**
+     * Current authoring head found
+     */
+    200: AuthoringState;
+};
+export type GetAuthoringHeadResponse = GetAuthoringHeadResponses[keyof GetAuthoringHeadResponses];
+export type CreateAuthoringStateData = {
+    body: CreateAuthoringStateRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/authoring/states';
+};
+export type CreateAuthoringStateErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Base authoring state does not match the current head
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateAuthoringStateError = CreateAuthoringStateErrors[keyof CreateAuthoringStateErrors];
+export type CreateAuthoringStateResponses = {
+    /**
+     * Authoring state created and promoted to head
+     */
+    201: AuthoringState;
+};
+export type CreateAuthoringStateResponse = CreateAuthoringStateResponses[keyof CreateAuthoringStateResponses];
+export type GetGameScriptsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query: {
+        /**
+         * The manifest ID to get compiled scripts for
+         */
+        manifestId: string;
+    };
+    url: '/api/games/{gameId}/scripts';
+};
+export type GetGameScriptsErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetGameScriptsError = GetGameScriptsErrors[keyof GetGameScriptsErrors];
+export type GetGameScriptsResponses = {
+    /**
+     * Game scripts retrieved successfully
+     */
+    200: GameScriptsResponse;
+};
+export type GetGameScriptsResponse = GetGameScriptsResponses[keyof GetGameScriptsResponses];
+export type GetActiveJobData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/jobs/active';
+};
+export type GetActiveJobErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetActiveJobError = GetActiveJobErrors[keyof GetActiveJobErrors];
+export type GetActiveJobResponses = {
+    /**
+     * Active job status (null if no active job)
+     */
+    200: ActiveJobResponse;
+};
+export type GetActiveJobResponse = GetActiveJobResponses[keyof GetActiveJobResponses];
+export type GetJobData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for any async job
+         */
+        jobId: string;
+    };
+    query?: never;
+    url: '/api/jobs/{jobId}';
+};
+export type GetJobErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetJobError = GetJobErrors[keyof GetJobErrors];
+export type GetJobResponses = {
+    /**
+     * Job details
+     */
+    200: JobDetailResponse;
+};
+export type GetJobResponse = GetJobResponses[keyof GetJobResponses];
+export type SubscribeToJobEventsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for any async job
+         */
+        jobId: string;
+    };
+    query?: never;
+    url: '/api/jobs/{jobId}/events';
+};
+export type SubscribeToJobEventsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type SubscribeToJobEventsError = SubscribeToJobEventsErrors[keyof SubscribeToJobEventsErrors];
+export type SubscribeToJobEventsResponses = {
+    /**
+     * SSE connection established
+     */
+    200: JobDetailResponse;
+};
+export type SubscribeToJobEventsResponse = SubscribeToJobEventsResponses[keyof SubscribeToJobEventsResponses];
+export type CreateGameRunData = {
+    body: CreateGameRunRequest;
+    path?: never;
+    query?: never;
+    url: '/api/runs';
+};
+export type CreateGameRunErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Conflict - version mismatch or resource state conflict
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateGameRunError = CreateGameRunErrors[keyof CreateGameRunErrors];
+export type CreateGameRunResponses = {
+    /**
+     * Game build run accepted
+     */
+    202: CreateGameRunResponse;
+};
+export type CreateGameRunResponse2 = CreateGameRunResponses[keyof CreateGameRunResponses];
+export type CancelGameRunData = {
+    body?: never;
+    path: {
+        jobId: string;
+    };
+    query?: never;
+    url: '/api/runs/{jobId}/cancel';
+};
+export type CancelGameRunErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CancelGameRunError = CancelGameRunErrors[keyof CancelGameRunErrors];
+export type CancelGameRunResponses = {
+    /**
+     * Game build run cancellation accepted
+     */
+    202: unknown;
+};
+export type ListGameRulesData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: {
+        /**
+         * Maximum number of rules to return (default: 10, max: 100)
+         */
+        limit?: number;
+    };
+    url: '/api/games/{gameId}/rules';
+};
+export type ListGameRulesErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type ListGameRulesError = ListGameRulesErrors[keyof ListGameRulesErrors];
+export type ListGameRulesResponses = {
+    /**
+     * Game rules retrieved successfully
+     */
+    200: ListGameRulesResponse;
+};
+export type ListGameRulesResponse2 = ListGameRulesResponses[keyof ListGameRulesResponses];
+export type CreateGameRuleData = {
+    body: CreateGameRuleRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/rules';
+};
+export type CreateGameRuleErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateGameRuleError = CreateGameRuleErrors[keyof CreateGameRuleErrors];
+export type CreateGameRuleResponses = {
+    /**
+     * Game rule created successfully
+     */
+    201: CreateGameRuleResponse;
+};
+export type CreateGameRuleResponse2 = CreateGameRuleResponses[keyof CreateGameRuleResponses];
+export type GetLatestGameRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/rules/latest';
+};
+export type GetLatestGameRuleErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetLatestGameRuleError = GetLatestGameRuleErrors[keyof GetLatestGameRuleErrors];
+export type GetLatestGameRuleResponses = {
+    /**
+     * Latest game rule retrieved successfully
+     */
+    200: GameRule;
+};
+export type GetLatestGameRuleResponse = GetLatestGameRuleResponses[keyof GetLatestGameRuleResponses];
+export type GetGameRuleData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game rule
+         */
+        ruleId: string;
+    };
+    query?: never;
+    url: '/api/rules/{ruleId}';
+};
+export type GetGameRuleErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetGameRuleError = GetGameRuleErrors[keyof GetGameRuleErrors];
+export type GetGameRuleResponses = {
+    /**
+     * Game rule retrieved successfully
+     */
+    200: GameRule;
+};
+export type GetGameRuleResponse = GetGameRuleResponses[keyof GetGameRuleResponses];
+export type CreateSessionData = {
+    body: CreateSessionRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/sessions';
+};
+export type CreateSessionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateSessionError = CreateSessionErrors[keyof CreateSessionErrors];
+export type CreateSessionResponses = {
+    /**
+     * Session created successfully
+     */
+    201: CreateSessionResponse;
+};
+export type CreateSessionResponse2 = CreateSessionResponses[keyof CreateSessionResponses];
+export type CreateSessionFromReducerSnapshotData = {
+    body: CreateSessionFromReducerSnapshotRequest;
+    path: {
+        /**
+         * Unique identifier for the game
+         */
+        gameId: string;
+    };
+    query?: never;
+    url: '/api/games/{gameId}/sessions/from-reducer-snapshot';
+};
+export type CreateSessionFromReducerSnapshotErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateSessionFromReducerSnapshotError = CreateSessionFromReducerSnapshotErrors[keyof CreateSessionFromReducerSnapshotErrors];
+export type CreateSessionFromReducerSnapshotResponses = {
+    /**
+     * Session materialized successfully
+     */
+    200: HostSessionSnapshot;
+};
+export type CreateSessionFromReducerSnapshotResponse = CreateSessionFromReducerSnapshotResponses[keyof CreateSessionFromReducerSnapshotResponses];
+export type GetSessionByShortCodeData = {
+    body?: never;
+    path: {
+        /**
+         * Memorable short code for the session (e.g., 'swift-falcon-73')
+         */
+        shortCode: string;
+    };
+    query?: {
+        /**
+         * Optional controlled player to include in the selected-perspective gameplay snapshot.
+         */
+        playerId?: string;
+    };
+    url: '/api/sessions/code/{shortCode}';
+};
+export type GetSessionByShortCodeErrors = {
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetSessionByShortCodeError = GetSessionByShortCodeErrors[keyof GetSessionByShortCodeErrors];
+export type GetSessionByShortCodeResponses = {
+    /**
+     * Session found successfully
+     */
+    200: HostSessionSnapshot;
+};
+export type GetSessionByShortCodeResponse = GetSessionByShortCodeResponses[keyof GetSessionByShortCodeResponses];
+export type GetSessionSnapshotData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query?: {
+        /**
+         * Optional controlled player to include in the selected-perspective gameplay snapshot.
+         */
+        playerId?: string;
+    };
+    url: '/api/sessions/{sessionId}/snapshot';
+};
+export type GetSessionSnapshotErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetSessionSnapshotError = GetSessionSnapshotErrors[keyof GetSessionSnapshotErrors];
+export type GetSessionSnapshotResponses = {
+    /**
+     * Session snapshot retrieved successfully
+     */
+    200: HostSessionSnapshot;
+};
+export type GetSessionSnapshotResponse = GetSessionSnapshotResponses[keyof GetSessionSnapshotResponses];
+export type SubscribeToSessionEventsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query: {
+        /**
+         * Stable browser-tab identifier used to replace stale reconnects from the same tab.
+         */
+        clientId: string;
+        /**
+         * Unique identifier for this specific connection attempt.
+         */
+        connectionAttemptId: string;
+        /**
+         * Optional caller label for diagnostics, such as `play-page` or `session-play-panel`.
+         */
+        clientSource?: string;
+        /**
+         * Optional controlled player for the selected gameplay perspective.
+         */
+        playerId?: string;
+    };
+    url: '/api/sessions/{sessionId}/events';
+};
+export type SubscribeToSessionEventsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Too many requests or live connections
+     */
+    429: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type SubscribeToSessionEventsError = SubscribeToSessionEventsErrors[keyof SubscribeToSessionEventsErrors];
+export type SubscribeToSessionEventsResponses = {
+    /**
+     * Server-Sent Events stream. Each event contains a JSON-serialized HostSessionEvent.
+     *
+     */
+    200: HostSessionEvent;
+};
+export type SubscribeToSessionEventsResponse = SubscribeToSessionEventsResponses[keyof SubscribeToSessionEventsResponses];
+export type DisconnectSessionEventsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query: {
+        /**
+         * Stable browser-tab identifier originally used to open the session event stream.
+         */
+        clientId: string;
+        /**
+         * Unique identifier for the specific connection attempt being released.
+         */
+        connectionAttemptId: string;
+        /**
+         * Optional selected player scope originally used to open the stream.
+         */
+        playerId?: string;
+    };
+    url: '/api/sessions/{sessionId}/events/disconnect';
+};
+export type DisconnectSessionEventsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+};
+export type DisconnectSessionEventsError = DisconnectSessionEventsErrors[keyof DisconnectSessionEventsErrors];
+export type DisconnectSessionEventsResponses = {
+    /**
+     * Disconnect request accepted
+     */
+    202: unknown;
+};
+export type SubscribeToGameLogsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query?: {
+        /**
+         * Last log ID received (for reconnection/replay)
+         */
+        lastLogId?: number;
+    };
+    url: '/api/sessions/{sessionId}/logs';
+};
+export type SubscribeToGameLogsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type SubscribeToGameLogsError = SubscribeToGameLogsErrors[keyof SubscribeToGameLogsErrors];
+export type SubscribeToGameLogsResponses = {
+    /**
+     * SSE connection established
+     */
+    200: LogMessageDto;
+};
+export type SubscribeToGameLogsResponse = SubscribeToGameLogsResponses[keyof SubscribeToGameLogsResponses];
+export type StartGameData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/start';
+};
+export type StartGameErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type StartGameError = StartGameErrors[keyof StartGameErrors];
+export type StartGameResponses = {
+    /**
+     * Game started successfully
+     */
+    200: HostSessionSnapshot;
+};
+export type StartGameResponse = StartGameResponses[keyof StartGameResponses];
+export type ListPlayerActionsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/players/{playerId}/actions';
+};
+export type ListPlayerActionsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type ListPlayerActionsError = ListPlayerActionsErrors[keyof ListPlayerActionsErrors];
+export type ListPlayerActionsResponses = {
+    /**
+     * Current actions returned successfully
+     */
+    200: PlayerActionsResponse;
+};
+export type ListPlayerActionsResponse = ListPlayerActionsResponses[keyof ListPlayerActionsResponses];
+export type DescribePlayerActionData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+        interactionId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/players/{playerId}/actions/{interactionId}';
+};
+export type DescribePlayerActionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type DescribePlayerActionError = DescribePlayerActionErrors[keyof DescribePlayerActionErrors];
+export type DescribePlayerActionResponses = {
+    /**
+     * Action descriptor returned successfully
+     */
+    200: PlayerActionResponse;
+};
+export type DescribePlayerActionResponse = DescribePlayerActionResponses[keyof DescribePlayerActionResponses];
+export type GetPlayerActionTargetsData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+        interactionId: string;
+        inputKey: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/players/{playerId}/actions/{interactionId}/targets/{inputKey}';
+};
+export type GetPlayerActionTargetsErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetPlayerActionTargetsError = GetPlayerActionTargetsErrors[keyof GetPlayerActionTargetsErrors];
+export type GetPlayerActionTargetsResponses = {
+    /**
+     * Input domain returned successfully
+     */
+    200: PlayerActionTargetsResponse;
+};
+export type GetPlayerActionTargetsResponse = GetPlayerActionTargetsResponses[keyof GetPlayerActionTargetsResponses];
+export type ValidatePlayerActionData = {
+    body: PlayerActionRequest;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+        interactionId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/players/{playerId}/actions/{interactionId}/validate';
+};
+export type ValidatePlayerActionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Conflict - version mismatch or resource state conflict
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type ValidatePlayerActionError = ValidatePlayerActionErrors[keyof ValidatePlayerActionErrors];
+export type ValidatePlayerActionResponses = {
+    /**
+     * Validation result returned successfully
+     */
+    200: PlayerActionValidateResponse;
+};
+export type ValidatePlayerActionResponse = ValidatePlayerActionResponses[keyof ValidatePlayerActionResponses];
+export type SubmitPlayerActionData = {
+    body: PlayerActionRequest;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+        interactionId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/players/{playerId}/actions/{interactionId}/submit';
+};
+export type SubmitPlayerActionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Conflict - version mismatch or resource state conflict
+     */
+    409: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type SubmitPlayerActionError = SubmitPlayerActionErrors[keyof SubmitPlayerActionErrors];
+export type SubmitPlayerActionResponses = {
+    /**
+     * Submission result returned successfully
+     */
+    200: HostActionSubmitResponse;
+};
+export type SubmitPlayerActionResponse = SubmitPlayerActionResponses[keyof SubmitPlayerActionResponses];
+export type AddSeatData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/seats';
+};
+export type AddSeatErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type AddSeatError = AddSeatErrors[keyof AddSeatErrors];
+export type AddSeatResponses = {
+    /**
+     * Seat added successfully
+     */
+    201: SeatAssignment;
+};
+export type AddSeatResponse = AddSeatResponses[keyof AddSeatResponses];
+export type RemoveSeatData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/seats/{playerId}';
+};
+export type RemoveSeatErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type RemoveSeatError = RemoveSeatErrors[keyof RemoveSeatErrors];
+export type RemoveSeatResponses = {
+    /**
+     * Seat removed successfully
+     */
+    204: void;
+};
+export type RemoveSeatResponse = RemoveSeatResponses[keyof RemoveSeatResponses];
+export type UpdateSeatData = {
+    body: UpdateSeatRequest;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/seats/{playerId}';
+};
+export type UpdateSeatErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type UpdateSeatError = UpdateSeatErrors[keyof UpdateSeatErrors];
+export type UpdateSeatResponses = {
+    /**
+     * Seat updated successfully
+     */
+    200: SeatAssignment;
+};
+export type UpdateSeatResponse = UpdateSeatResponses[keyof UpdateSeatResponses];
+export type AssignSeatData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/seats/{playerId}/assign';
+};
+export type AssignSeatErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type AssignSeatError = AssignSeatErrors[keyof AssignSeatErrors];
+export type AssignSeatResponses = {
+    /**
+     * Seat assigned successfully
+     */
+    204: void;
+};
+export type AssignSeatResponse = AssignSeatResponses[keyof AssignSeatResponses];
+export type RestoreHistoryData = {
+    body: RestoreHistoryRequest;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/history/restore';
+};
+export type RestoreHistoryErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type RestoreHistoryError = RestoreHistoryErrors[keyof RestoreHistoryErrors];
+export type RestoreHistoryResponses = {
+    /**
+     * Game state restored successfully
+     */
+    200: RestoreHistoryResponse;
+};
+export type RestoreHistoryResponse2 = RestoreHistoryResponses[keyof RestoreHistoryResponses];
+export type UnassignSeatData = {
+    body?: never;
+    path: {
+        /**
+         * Unique identifier for the game session
+         */
+        sessionId: string;
+        /**
+         * Unique identifier for the player (e.g., 'player-1')
+         */
+        playerId: string;
+    };
+    query?: never;
+    url: '/api/sessions/{sessionId}/seats/{playerId}/unassign';
+};
+export type UnassignSeatErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Forbidden - insufficient permissions
+     */
+    403: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type UnassignSeatError = UnassignSeatErrors[keyof UnassignSeatErrors];
+export type UnassignSeatResponses = {
+    /**
+     * Seat unassigned successfully
+     */
+    204: void;
+};
+export type UnassignSeatResponse = UnassignSeatResponses[keyof UnassignSeatResponses];
+export type FetchUiBundleData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * ID of the game to fetch the UI bundle for (user-compiled sessions)
+         */
+        gameId?: string;
+        /**
+         * When set with demo auth headers, fetch the UI bundle for that demo session's catalog revision
+         */
+        sessionId?: string;
+    };
+    url: '/api/ui-bundles/fetch';
+};
+export type FetchUiBundleErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Unauthorized - authentication required
+     */
+    401: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type FetchUiBundleError = FetchUiBundleErrors[keyof FetchUiBundleErrors];
+export type FetchUiBundleResponses = {
+    /**
+     * HTML content of the UI bundle
+     */
+    200: string;
+};
+export type FetchUiBundleResponse = FetchUiBundleResponses[keyof FetchUiBundleResponses];
+export type ListDemoGamesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/demo-games';
+};
+export type ListDemoGamesErrors = {
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type ListDemoGamesError = ListDemoGamesErrors[keyof ListDemoGamesErrors];
+export type ListDemoGamesResponses = {
+    /**
+     * Successfully retrieved demo games
+     */
+    200: Array<DemoGameSummary>;
+};
+export type ListDemoGamesResponse = ListDemoGamesResponses[keyof ListDemoGamesResponses];
+export type GetDemoGameData = {
+    body?: never;
+    path: {
+        /**
+         * Demo game slug
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/api/demo-games/{slug}';
+};
+export type GetDemoGameErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetDemoGameError = GetDemoGameErrors[keyof GetDemoGameErrors];
+export type GetDemoGameResponses = {
+    /**
+     * Successfully retrieved demo game metadata
+     */
+    200: DemoGameDetails;
+};
+export type GetDemoGameResponse = GetDemoGameResponses[keyof GetDemoGameResponses];
+export type GetDemoGameThumbnailData = {
+    body?: never;
+    path: {
+        /**
+         * Demo game slug
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/api/demo-games/{slug}/thumbnail';
+};
+export type GetDemoGameThumbnailErrors = {
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type GetDemoGameThumbnailError = GetDemoGameThumbnailErrors[keyof GetDemoGameThumbnailErrors];
+export type GetDemoGameThumbnailResponses = {
+    /**
+     * Successfully retrieved demo thumbnail
+     */
+    200: Blob | File;
+};
+export type GetDemoGameThumbnailResponse = GetDemoGameThumbnailResponses[keyof GetDemoGameThumbnailResponses];
+export type CreateDemoGameSessionData = {
+    body?: never;
+    path: {
+        /**
+         * Demo game slug
+         */
+        slug: string;
+    };
+    query?: never;
+    url: '/api/demo-games/{slug}/sessions';
+};
+export type CreateDemoGameSessionErrors = {
+    /**
+     * Bad request - invalid input parameters
+     */
+    400: ProblemDetails;
+    /**
+     * Resource not found
+     */
+    404: ProblemDetails;
+    /**
+     * Internal server error
+     */
+    500: ProblemDetails;
+};
+export type CreateDemoGameSessionError = CreateDemoGameSessionErrors[keyof CreateDemoGameSessionErrors];
+export type CreateDemoGameSessionResponses = {
+    /**
+     * Demo session created successfully
+     */
+    201: DemoSessionResponse;
+};
+export type CreateDemoGameSessionResponse = CreateDemoGameSessionResponses[keyof CreateDemoGameSessionResponses];
+//# sourceMappingURL=types.gen.d.ts.map