island-battles-python 0.1.0__py3-none-any.whl

island_battles_client/_generated.py

@@ -0,0 +1,870 @@
+# Generated by scripts/generate.py from backend/api/openapi.json. Do not edit;
+# change the Go API types, export the document, and regenerate instead.
+
+from collections.abc import Mapping, Sequence
+from enum import StrEnum
+from typing import Annotated, Any, Literal
+from uuid import UUID
+
+from island_battles_client._entities import (
+    BoardEntity,
+    GameModel,
+    GenerationBase,
+    SoldierGroupBase,
+)
+from pydantic import (
+    AnyUrl,
+    AwareDatetime,
+    ConfigDict,
+    Field,
+    RootModel,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+)
+
+
+class BotChoice(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    kind: Literal["localhost", "default"]
+    """
+    localhost: the player's own bot, which island-battles-bot serve runs on their machine; their game client relays each turn to it and submits its answer. default: a default bot of GET /bots/defaults, which the backend plays itself, so the player's client submits nothing.
+    """
+    level: Annotated[StrictInt | None, Field(ge=1)] = None
+    """
+    For kind default, the level of the default bot, one that GET /bots/defaults lists. Absent for kind localhost.
+    """
+
+
+class BotTurn(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    game_id: Annotated[StrictInt, Field(ge=1)]
+    generation: Generation
+    memory: Mapping[str, Any] | None
+    """
+    The memory the bot returned with its previous turn in this game, or null on its first turn and after a turn that returned null.
+    """
+    team_color: Annotated[StrictInt, Field(ge=1)]
+    turn_deadline_at: AwareDatetime | None
+    """
+    When the turn times out, GenerationState.turn_deadline_at, or null when turns have no time limit. A bot that hasn't answered by then makes its whole team lose.
+    """
+    upgrades: Sequence[Upgrade]
+    """
+    The upgrade cost table, the same list GET /game/upgrades returns as its upgrades. It is the same for the whole game, so a client reads it once and reuses it in every turn. Reaching a level costs its soldier_cost.
+    """
+
+
+class BotTurnResult(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    commands: Annotated[Sequence[PublicGenerationCommand], Field(max_length=1000)]
+    logs: Annotated[Sequence[GenerationLogLine], Field(max_length=100)]
+    """
+    Game log lines for this turn, of at most 500 characters each.
+    """
+    memory: Mapping[str, Any] | None
+    """
+    Any JSON object of at most 64 KiB as compact JSON, given back as BotTurn.memory next turn, or null for none.
+    """
+
+
+class Castle(BoardEntity):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Castle ID, stable for the whole game.
+    """
+    soldiers: Annotated[StrictInt, Field(ge=0)]
+    team_color: Annotated[StrictInt, Field(ge=0)]
+    """
+    Owning team; 0 is neutral.
+    """
+    upgrades: Mapping[UpgradeType, StrictInt]
+    """
+    Every upgrade type's level. GET /game/upgrades lists the levels and what the next one costs.
+    """
+    x: StrictFloat
+    y: StrictFloat
+
+
+class CastleTemplate(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    starting_soldier_amount: Annotated[StrictInt | None, Field(ge=0)] = None
+    """
+    Soldiers in the castle when a game starts. Defaults to neutral_starting_soldier_amount.
+    """
+    team_color: Annotated[StrictInt, Field(ge=0)]
+    """
+    Owning team colour, from 1 to player_amount; 0 is neutral.
+    """
+    upgrades: Mapping[UpgradeType, StrictInt] | None = None
+    """
+    Starting level of each upgrade type. Omitted types start at level 1.
+    """
+    x: StrictFloat
+    """
+    Distance from the centre of the plane, between -plane_size_x/2 and plane_size_x/2.
+    """
+    y: StrictFloat
+    """
+    Distance from the centre of the plane, between -plane_size_y/2 and plane_size_y/2.
+    """
+
+
+class Clash(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    id: Annotated[StrictInt, Field(ge=1)]
+    """
+    Identifies the clash within its generation.
+    """
+    participants: Sequence[ClashParticipant]
+    time: Annotated[StrictFloat, Field(ge=0.0, le=1.0)]
+    """
+    Fraction of the turn at which contact happened.
+    """
+
+
+class ClashParticipant(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    clash_radius: Annotated[StrictFloat, Field(gt=0.0)]
+    group_id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Soldier group ID; the group may no longer exist.
+    """
+    soldiers_after: Annotated[StrictInt, Field(ge=0)]
+    """
+    Soldiers immediately after this contact; 0 means the group was defeated.
+    """
+    soldiers_before: Annotated[StrictInt, Field(ge=0)]
+    """
+    Soldiers immediately before this contact.
+    """
+    team_color: Annotated[StrictInt, Field(ge=0)]
+    x: StrictFloat
+    y: StrictFloat
+
+
+class ConnectionToken(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(alias="$schema", examples=["https://example.com/ConnectionToken.json"]),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    expires_at: AwareDatetime
+    token: StrictStr
+    websocket_url: AnyUrl
+
+
+class ConnectionTokenInputBody(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(
+            alias="$schema",
+            examples=["https://example.com/ConnectionTokenInputBody.json"],
+        ),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+
+
+class DefaultBot(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    description: StrictStr
+    """
+    How the bot plays, in a sentence or two.
+    """
+    level: Annotated[StrictInt, Field(ge=1)]
+    """
+    The bot's level. Higher levels play better.
+    """
+    name: StrictStr
+    """
+    A short name to show in a bot picker.
+    """
+
+
+class Demo(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    format: Literal["island-battles-demo"]
+    """
+    Marks the file as an Island Battles demo.
+    """
+    frames: Annotated[Sequence[Generation], Field(min_length=1)]
+    """
+    Every generation played when the demo was saved, in order. Each is the board view that players received.
+    """
+    game_id: Annotated[StrictInt, Field(ge=1)]
+    logs: Sequence[GenerationLogs]
+    """
+    One entry per frame, in the same order, with the game log lines its saver could see when saving: while the game runs only the saver's team's, once it has ended every team's. hidden_team_colors names the teams left out.
+    """
+    outcome: GameOutcome | None
+    """
+    How the game ended, or null when the demo was saved while the game was still running.
+    """
+    saved_at: AwareDatetime
+    """
+    When the demo was saved.
+    """
+    schema_version: Literal[1]
+    """
+    The demo format's version. The demo viewer opens only the current version and rejects a demo saved by another version of the game.
+    """
+    teams: Sequence[GameTeam]
+    """
+    The teams that played, with their lobby names and the display names their players had at the start.
+    """
+
+
+class ErrorDetail(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    location: StrictStr | None = None
+    """
+    Where the error occurred, e.g. 'body.items[3].tags' or 'path.thing-id'
+    """
+    message: StrictStr | None = None
+    """
+    Error message text
+    """
+    value: Any | None = None
+    """
+    The value at the given location
+    """
+
+
+class ErrorModel(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(alias="$schema", examples=["https://example.com/ErrorModel.json"]),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    detail: Annotated[
+        StrictStr | None, Field(examples=["Property foo is required but is missing."])
+    ] = None
+    """
+    A human-readable explanation specific to this occurrence of the problem.
+    """
+    errors: Sequence[ErrorDetail] | None = None
+    """
+    Optional list of individual error details
+    """
+    instance: Annotated[
+        AnyUrl | None, Field(examples=["https://example.com/error-log/abc123"])
+    ] = None
+    """
+    A URI reference that identifies the specific occurrence of the problem.
+    """
+    status: Annotated[StrictInt | None, Field(examples=[400])] = None
+    """
+    HTTP status code
+    """
+    title: Annotated[StrictStr | None, Field(examples=["Bad Request"])] = None
+    """
+    A short, human-readable summary of the problem type. This value should not change between occurrences of the error.
+    """
+    type: Annotated[
+        AnyUrl | None, Field(examples=["https://example.com/errors/example"])
+    ] = "about:blank"
+    """
+    A URI reference to human-readable documentation for the error.
+    """
+
+
+class GameEndedEvent(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    schema_version: Literal[1]
+    state: GenerationState
+    """
+    The final generation, with its outcome.
+    """
+    type: Literal["game.ended"]
+
+
+class GameOutcome(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    reason: Literal[
+        "last_team_standing", "all_eliminated", "generation_cap", "turn_timeout"
+    ]
+    """
+    last_team_standing: one team was left after every other team lost all its castles and soldier groups. all_eliminated: the last teams were eliminated in the same turn, a draw. generation_cap: the game reached its last generation; the team with the most castles won, and equal counts are a draw. turn_timeout: a turn passed its deadline; every team with a player who hadn't completed it lost, and among the other teams still standing the team with the most castles won, while equal counts, or no team left, are a draw.
+    """
+    summary: StrictStr
+    """
+    The outcome in one sentence, naming the winning team, and for turn_timeout the teams that lost and their players who didn't answer.
+    """
+    winner_team_color: Annotated[StrictInt | None, Field(ge=1)]
+    """
+    The winning team, or null for a draw.
+    """
+
+
+class GameTeam(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    color: Annotated[StrictInt, Field(ge=1)]
+    """
+    The team colour that castles and soldier groups carry as team_color.
+    """
+    name: StrictStr
+    players: Sequence[StrictStr]
+    """
+    The display names the team's players had at the start.
+    """
+
+
+class Generation(GenerationBase):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    castles: Sequence[Castle]
+    clashes: Sequence[Clash]
+    id: Annotated[StrictInt, Field(ge=1)]
+    """
+    Generation ID; increases with every turn.
+    """
+    soldier_groups: Sequence[SoldierGroup]
+
+
+class GenerationEvent(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    schema_version: Literal[1]
+    state: GenerationState
+    type: Literal["game.next_generation"]
+
+
+class GenerationLogLine(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    level: Literal["debug", "info", "warning", "error"]
+    logger: Annotated[StrictStr, Field(max_length=100)]
+    """
+    The name of the logger that wrote the line, such as island_battles.player.
+    """
+    message: Annotated[StrictStr, Field(max_length=500, min_length=1)]
+    """
+    The line, of 1 to 500 Unicode code points. A client cuts a longer line to fit and says so at its end.
+    """
+
+
+class GenerationLogs(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(alias="$schema", examples=["https://example.com/GenerationLogs.json"]),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    generation_id: Annotated[StrictInt, Field(ge=1)]
+    hidden_team_colors: Sequence[HiddenTeamColor]
+    """
+    Teams whose logs you can't see yet. While the game runs you see only your own team's logs; once it has an outcome you see every team's.
+    """
+    players: Sequence[PlayerGenerationLogs]
+    """
+    Every player of the teams you can see, ordered by team colour and then display name, with their lines in the order they were written.
+    """
+
+
+class GenerationState(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(alias="$schema", examples=["https://example.com/GenerationState.json"]),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    bot: BotChoice
+    """
+    Your bot in this game, the one you chose in the lobby, copied when the game started. For kind localhost your client relays each turn to your bot and submits its answer. For kind default the backend plays your turns itself as soon as each generation is created, so your client submits nothing.
+    """
+    channel: StrictStr
+    """
+    Your personal Centrifugo channel, which receives GenerationEvent after each turn and GameEndedEvent after the last one.
+    """
+    game_id: Annotated[StrictInt, Field(ge=1)]
+    generation: Generation
+    generation_id: Annotated[StrictInt, Field(ge=1)]
+    lobby_id: UUID
+    log_lines_stored: Annotated[StrictInt, Field(ge=0)]
+    """
+    How many game log lines you have stored for this generation, out of the 100 a player may store per generation. 0 when there are none. A client that restarts during a turn continues counting from it.
+    """
+    memory: Mapping[str, Any] | None
+    """
+    The memory sent with your latest completed turn of this game, for your bot's next BotTurn.memory. Null before your first completed turn, and after a completed turn without memory.
+    """
+    outcome: GameOutcome | None = None
+    """
+    How the game ended. Absent while the game runs. A finished game keeps its final generation and rejects every command.
+    """
+    player_id: UUID
+    submitted: StrictBool
+    """
+    Whether you completed this generation's turn.
+    """
+    team_color: Annotated[StrictInt, Field(ge=1)]
+    turn_deadline_at: AwareDatetime | None
+    """
+    When this generation's turn times out: the generation's creation time plus the lobby's turn_timeout_seconds. Null when turns have no time limit, and once the game has ended. If a player of a team hasn't completed the turn by then, the team loses and the game ends. A client waiting for other players calls POST /game/from-lobby/{lobby_id}/deadline about a second after it, because the server runs no timers.
+    """
+
+
+class HiddenTeamColor(RootModel[StrictInt]):
+    root: Annotated[StrictInt, Field(ge=0)]
+
+
+class ListDefaultBotsResponseBody(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(
+            alias="$schema",
+            examples=["https://example.com/ListDefaultBotsResponseBody.json"],
+        ),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    bots: Sequence[DefaultBot]
+
+
+class ListMapTemplatesResponseBody(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(
+            alias="$schema",
+            examples=["https://example.com/ListMapTemplatesResponseBody.json"],
+        ),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    maps: Sequence[MapTemplateSummary]
+
+
+class ListUpgradesResponseBody(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(
+            alias="$schema",
+            examples=["https://example.com/ListUpgradesResponseBody.json"],
+        ),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    upgrades: Sequence[Upgrade]
+
+
+class LobbyBots(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(alias="$schema", examples=["https://example.com/LobbyBots.json"]),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    lobby_id: UUID
+    members: Sequence[LobbyMemberBot]
+    """
+    Every member of the lobby, in the lobby's member order, bot seats included.
+    """
+
+
+class LobbyMemberBot(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    bot: BotChoice | None = None
+    """
+    The member's bot. Absent until they choose one, and a member can't get ready without one. A bot seat that the host added has the default bot of its level.
+    """
+    display_name: StrictStr
+    player_id: UUID
+
+
+class LobbySettings(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    map: MapTemplate | None = None
+    """
+    Start on this map file. Cannot be combined with map_template_id.
+    """
+    map_template_id: Annotated[StrictInt | None, Field(ge=1)] = None
+    """
+    Start on this default map, a map_template_id from GET /map/templates. Cannot be combined with map.
+    """
+    turn_timeout_seconds: Annotated[StrictInt | None, Field(ge=5, le=600)] = 30
+    """
+    How long each turn lasts, in whole seconds from 5 to 600, counted from when its generation was created; 30 when left out. null means no limit, for example while debugging a bot. When a turn's deadline passes before every player has completed it, each team with a player who hadn't loses, and the game ends.
+    """
+
+
+class MapTemplate(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    castles: Annotated[Sequence[CastleTemplate], Field(min_length=1)]
+    """
+    Each castle's position in the list is its castle ID in every game built from the map.
+    """
+    map_name: Annotated[StrictStr, Field(min_length=1)]
+    """
+    Name of the map, unique among default maps.
+    """
+    neutral_starting_soldier_amount: Annotated[StrictInt, Field(ge=0)]
+    """
+    Soldiers in every castle, owned or neutral, that sets no starting_soldier_amount.
+    """
+    plane_size_x: Annotated[StrictInt, Field(ge=1)]
+    """
+    Width of the plane, which is centred on the origin.
+    """
+    plane_size_y: Annotated[StrictInt, Field(ge=1)]
+    """
+    Height of the plane, which is centred on the origin.
+    """
+    player_amount: Annotated[StrictInt, Field(ge=1)]
+    """
+    Players the map is made for. Castle team colours run from 1 to player_amount.
+    """
+
+
+class MapTemplateSummary(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    castle_count: StrictInt
+    """
+    Castles on the map, team and neutral.
+    """
+    map_name: StrictStr
+    map_template_id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Choose the map by passing this ID as game_settings.map_template_id when creating a lobby.
+    """
+    plane_size_x: Annotated[StrictInt, Field(ge=0)]
+    plane_size_y: Annotated[StrictInt, Field(ge=0)]
+    team_count: StrictInt
+    """
+    Teams the map is made for, its player_amount. A lobby on this map has exactly this many teams, in team colour order.
+    """
+
+
+class PlayerGenerationLogs(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    display_name: StrictStr
+    lines: Sequence[GenerationLogLine]
+    team_color: Annotated[StrictInt, Field(ge=1)]
+
+
+class Problem(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    code: Literal[
+        "unauthenticated",
+        "not_found",
+        "not_host",
+        "lobby_full",
+        "team_full",
+        "phase_conflict",
+        "not_ready",
+        "empty_teams",
+        "stale_membership",
+        "idempotency_conflict",
+        "invalid_input",
+        "invalid_game_settings",
+        "invalid_seat_settings",
+        "game_requirement",
+        "watcher_kicked",
+        "watchers_full",
+        "unavailable",
+        "internal_error",
+    ]
+    detail: StrictStr
+    status: StrictInt
+    team_ids: Sequence[StrictStr] | None = None
+    """
+    The teams the error is about. For empty_teams, the teams that still need a player, in team order.
+    """
+    title: StrictStr
+    type: StrictStr | None = None
+    """
+    For game_requirement, the game's own problem type, a URI that the game documents, such as one meaning a player has yet to choose something in the game's API. Absent for every other code.
+    """
+
+
+class RegisterGenerationCommands(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(
+            alias="$schema",
+            examples=["https://example.com/RegisterGenerationCommands.json"],
+        ),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    commands: Annotated[Sequence[PublicGenerationCommand], Field(max_length=1000)]
+    complete: StrictBool | None = None
+    """
+    Seals your turn after this batch. Defaults to true.
+    """
+    game_id: Annotated[StrictInt, Field(ge=1)]
+    generation_id: Annotated[StrictInt, Field(ge=1)]
+    logs: Annotated[Sequence[GenerationLogLine] | None, Field(max_length=100)] = None
+    """
+    Game log lines written since your previous batch for this generation, appended in order after the lines already stored. At most 100 lines per player per generation, each of at most 500 characters; a batch that would break either limit is rejected whole with 422 and problem type urn:island-battles:problem:game-log-limit.
+    """
+    memory: Mapping[str, Any] | None = None
+    """
+    Your bot's memory, the BotTurnResult.memory it returned: any JSON object of at most 64 KiB as compact JSON. Only the batch with complete true saves it, replacing your previous memory, and an absent or null memory clears it; other batches ignore it. GenerationState.memory returns it. Larger memory is rejected whole with 422 and problem type urn:island-battles:problem:bot-memory-too-large.
+    """
+    request_id: UUID
+    """
+    Identifies this batch. Retry a lost request with the same UUID and body; use a new UUID for every new batch.
+    """
+
+
+class SendSoldierGroupCommand(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    command_type: Literal["send_soldier_group"]
+    parameters: SendSoldierGroupParameters
+
+
+class SendSoldierGroupParameters(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    destination_castle_id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Any other castle.
+    """
+    origin_castle_id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Castle your team owns.
+    """
+    soldier_amount: Annotated[StrictInt, Field(ge=1)]
+    """
+    Soldiers to send; counts against soldiers already reserved by your team this turn.
+    """
+
+
+class SoldierGroup(SoldierGroupBase):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    clash_radius: Annotated[StrictFloat, Field(gt=0.0)]
+    """
+    Enemies clash when their centers are within the larger of their radii.
+    """
+    destination_castle_id: Annotated[StrictInt, Field(ge=0)]
+    id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Soldier group ID, never reassigned within a game.
+    """
+    origin_castle_id: Annotated[StrictInt, Field(ge=0)]
+    soldiers: Annotated[StrictInt, Field(ge=0)]
+    team_color: Annotated[StrictInt, Field(ge=0)]
+    """
+    Owning team; 0 is neutral.
+    """
+    upgrades: Mapping[UpgradeType, StrictInt]
+    """
+    Every upgrade type's level, copied from the origin castle when the group left.
+    """
+    x: StrictFloat
+    y: StrictFloat
+
+
+class Upgrade(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    description: StrictStr
+    """
+    What the levels' values measure.
+    """
+    levels: Sequence[UpgradeLevel]
+    """
+    Every level from 1 to max_level, in order.
+    """
+    max_level: Annotated[StrictInt, Field(ge=1)]
+    """
+    The highest level. Every castle starts at level 1.
+    """
+    type: UpgradeType
+
+
+class UpgradeCastleCommand(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    command_type: Literal["upgrade_castle"]
+    parameters: UpgradeCastleParameters
+
+
+class PublicGenerationCommand(
+    RootModel[SendSoldierGroupCommand | UpgradeCastleCommand]
+):
+    root: Annotated[
+        SendSoldierGroupCommand | UpgradeCastleCommand,
+        Field(discriminator="command_type"),
+    ]
+
+
+class UpgradeCastleParameters(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    castle_id: Annotated[StrictInt, Field(ge=0)]
+    """
+    Castle your team owns. It pays the level's soldier_cost from GET /game/upgrades.
+    """
+    upgrade_type: UpgradeType
+    """
+    The type to raise by one level. Several upgrades of a castle in one turn each buy the next level.
+    """
+
+
+class UpgradeLevel(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    level: Annotated[StrictInt, Field(ge=1)]
+    soldier_cost: Annotated[StrictInt, Field(ge=0)]
+    """
+    Soldiers the castle pays to reach this level from the level below. Level 1 is free.
+    """
+    value: StrictFloat
+    """
+    The level's effect, in the unit its type's description names.
+    """
+
+
+class UpgradeType(StrEnum):
+    clash_stop_generations = "clash_stop_generations"
+    speed = "speed"
+
+
+class WatchGameEndedEvent(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    schema_version: Literal[1]
+    state: WatchState
+    """
+    The final generation, with its outcome.
+    """
+    type: Literal["game.ended"]
+
+
+class WatchGenerationEvent(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    schema_version: Literal[1]
+    state: WatchState
+    type: Literal["game.next_generation"]
+
+
+class WatchState(GameModel):
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    field_schema: Annotated[
+        AnyUrl | None,
+        Field(alias="$schema", examples=["https://example.com/WatchState.json"]),
+    ] = None
+    """
+    A URL to the JSON Schema for this object.
+    """
+    channel: StrictStr
+    """
+    The lobby's watch channel, watch:island-battles:<lobby_id>, which receives WatchGenerationEvent after each turn and WatchGameEndedEvent after the last one.
+    """
+    game_id: Annotated[StrictInt, Field(ge=1)]
+    generation: Generation
+    generation_id: Annotated[StrictInt, Field(ge=1)]
+    lobby_id: UUID
+    outcome: GameOutcome | None = None
+    """
+    How the game ended. Absent while the game runs.
+    """
+    teams: Sequence[GameTeam]
+    """
+    The teams that play, with their lobby names and the display names their players had at the start.
+    """
+    turn_deadline_at: AwareDatetime | None
+    """
+    When this generation's turn times out, as in GenerationState. Null when turns have no time limit, and once the game has ended. Watchers never apply a deadline themselves.
+    """