@diffenderfer-games/hub-contract 2.0.0-next.0 → 2.0.0-next.2

package/dist/index.d.ts

@@ -87,7 +87,6 @@ export type PlayerLite = z.infer<typeof PlayerLite>;
 //#endregion
 //#region src/errors/index.d.ts
 declare const errorCode: z.ZodEnum<{
-  ended: "ended";
   bad_request: "bad_request";
   signed_out: "signed_out";
   suspended: "suspended";
@@ -124,6 +123,9 @@ declare const errorCode: z.ZodEnum<{
   bad_info: "bad_info";
   launch_invalid: "launch_invalid";
   not_joinable: "not_joinable";
+  link_invalid: "link_invalid";
+  link_room_gone: "link_room_gone";
+  too_many_links: "too_many_links";
   bad_quick: "bad_quick";
   room_not_found: "room_not_found";
   not_in_room: "not_in_room";
@@ -133,6 +135,7 @@ declare const errorCode: z.ZodEnum<{
   in_progress: "in_progress";
   room_full: "room_full";
   not_ready: "not_ready";
+  ended: "ended";
   bad_patch: "bad_patch";
   race_room: "race_room";
   not_race: "not_race";
@@ -142,6 +145,14 @@ declare const errorCode: z.ZodEnum<{
   too_fast: "too_fast";
   bad_stats: "bad_stats";
   bad_param: "bad_param";
+  tournament_not_found: "tournament_not_found";
+  tournament_closed: "tournament_closed";
+  tournament_full: "tournament_full";
+  tournament_over: "tournament_over";
+  not_creator: "not_creator";
+  not_entered: "not_entered";
+  cannot_join: "cannot_join";
+  match_not_ready: "match_not_ready";
 }>;
 /** The type of the {@link ErrorCode} schema. */
 export interface ErrorCodeSchema extends Readonly<typeof errorCode> {}
@@ -155,7 +166,6 @@ declare const rejectReason: z.ZodEnum<{
   not_friends: "not_friends";
   dms_closed: "dms_closed";
   link: "link";
-  empty: "empty";
   personal_info: "personal_info";
   contact: "contact";
   language: "language";
@@ -168,6 +178,7 @@ declare const rejectReason: z.ZodEnum<{
   spam: "spam";
   shouting: "shouting";
   too_long: "too_long";
+  empty: "empty";
   chars: "chars";
   reserved: "reserved";
   muted: "muted";
@@ -188,7 +199,6 @@ export type RejectReason = z.infer<RejectReasonSchema>;
 declare const errorBody: z.ZodObject<{
   error: z.ZodString;
   code: z.ZodOptional<z.ZodEnum<{
-    ended: "ended";
     bad_request: "bad_request";
     signed_out: "signed_out";
     suspended: "suspended";
@@ -225,6 +235,9 @@ declare const errorBody: z.ZodObject<{
     bad_info: "bad_info";
     launch_invalid: "launch_invalid";
     not_joinable: "not_joinable";
+    link_invalid: "link_invalid";
+    link_room_gone: "link_room_gone";
+    too_many_links: "too_many_links";
     bad_quick: "bad_quick";
     room_not_found: "room_not_found";
     not_in_room: "not_in_room";
@@ -234,6 +247,7 @@ declare const errorBody: z.ZodObject<{
     in_progress: "in_progress";
     room_full: "room_full";
     not_ready: "not_ready";
+    ended: "ended";
     bad_patch: "bad_patch";
     race_room: "race_room";
     not_race: "not_race";
@@ -243,6 +257,14 @@ declare const errorBody: z.ZodObject<{
     too_fast: "too_fast";
     bad_stats: "bad_stats";
     bad_param: "bad_param";
+    tournament_not_found: "tournament_not_found";
+    tournament_closed: "tournament_closed";
+    tournament_full: "tournament_full";
+    tournament_over: "tournament_over";
+    not_creator: "not_creator";
+    not_entered: "not_entered";
+    cannot_join: "cannot_join";
+    match_not_ready: "match_not_ready";
   }>>;
   reason: z.ZodOptional<z.ZodEnum<{
     suspended: "suspended";
@@ -250,7 +272,6 @@ declare const errorBody: z.ZodObject<{
     not_friends: "not_friends";
     dms_closed: "dms_closed";
     link: "link";
-    empty: "empty";
     personal_info: "personal_info";
     contact: "contact";
     language: "language";
@@ -263,6 +284,7 @@ declare const errorBody: z.ZodObject<{
     spam: "spam";
     shouting: "shouting";
     too_long: "too_long";
+    empty: "empty";
     chars: "chars";
     reserved: "reserved";
     muted: "muted";
@@ -673,6 +695,88 @@ export declare const authEndpoints: {
   }, {}, import("@ayepi/core").EmptyObject>;
 };
 //#endregion
+//#region src/api/catalog-activity.d.ts
+/**
+ * How many people have a game open right now: claimed accounts and guests.
+ * Counts only, so no player is ever identified.
+ */
+export declare const GamePlayerCount: z.ZodObject<{
+  accounts: z.ZodNumber;
+  guests: z.ZodNumber;
+}, z.core.$strip>;
+/** How many people have a game open right now. */
+export type GamePlayerCount = z.infer<typeof GamePlayerCount>;
+/** Head counts per game slug; games nobody has open are absent. */
+export declare const GamePlayerCounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+  accounts: z.ZodNumber;
+  guests: z.ZodNumber;
+}, z.core.$strip>>;
+/** Head counts per game slug. */
+export type GamePlayerCounts = z.infer<typeof GamePlayerCounts>;
+/** The caller's activity in one game, within the analytics retention window. */
+export declare const MyGameActivity: z.ZodObject<{
+  plays: z.ZodNumber;
+  minutesPlayed: z.ZodNumber;
+  firstPlayedAt: z.ZodNullable<z.ZodNumber>;
+  lastPlayedAt: z.ZodNullable<z.ZodNumber>;
+  windowDays: z.ZodNumber;
+}, z.core.$strip>;
+/** The caller's activity in one game. */
+export type MyGameActivity = z.infer<typeof MyGameActivity>;
+/** The activity endpoints (part of the catalog area). */
+export declare const catalogActivityEndpoints: {
+  getMyGameActivity: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/me/activity";
+    readonly response: z.ZodObject<{
+      plays: z.ZodNumber;
+      minutesPlayed: z.ZodNumber;
+      firstPlayedAt: z.ZodNullable<z.ZodNumber>;
+      lastPlayedAt: z.ZodNullable<z.ZodNumber>;
+      windowDays: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "The caller's plays and time played in this game";
+      readonly tags: readonly ["catalog"];
+    };
+  }, {
+    user: {
+      id: number;
+      username: string;
+      guest: boolean;
+      role: "" | "admin";
+      avatar: string;
+      chatLock: boolean;
+      mutedUntil: number;
+      suspendedUntil: number;
+    };
+    clientId: string;
+  }, {
+    slug: z.ZodString;
+  }, {}>;
+  getGamePlayerCounts: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/catalog/players";
+    readonly response: z.ZodObject<{
+      games: z.ZodRecord<z.ZodString, z.ZodObject<{
+        accounts: z.ZodNumber;
+        guests: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly doc: {
+      readonly summary: "How many accounts and guests have each game open right now (counts only)";
+      readonly tags: readonly ["catalog"];
+    };
+  }, {
+    user: SessionUser | null;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+};
+//#endregion
 //#region src/api/catalog.d.ts
 /** A `[min, max]` player count, each 1 to 8. */
 export declare const PlayerRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
@@ -772,6 +876,7 @@ export declare const GameInfo: z.ZodObject<{
       }>;
     }, z.core.$strip>>;
   }, z.core.$strip>>;
+  tournaments: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
 /** A listed game. */
 export type GameInfo = z.infer<typeof GameInfo>;
@@ -904,6 +1009,7 @@ export declare const catalogEndpoints: {
             }>;
           }, z.core.$strip>>;
         }, z.core.$strip>>;
+        tournaments: z.ZodOptional<z.ZodLiteral<true>>;
       }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly doc: {
@@ -941,6 +1047,56 @@ export declare const catalogEndpoints: {
     user: SessionUser | null;
     clientId: string;
   }, {}, import("@ayepi/core").EmptyObject>;
+  getMyGameActivity: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/me/activity";
+    readonly response: z.ZodObject<{
+      plays: z.ZodNumber;
+      minutesPlayed: z.ZodNumber;
+      firstPlayedAt: z.ZodNullable<z.ZodNumber>;
+      lastPlayedAt: z.ZodNullable<z.ZodNumber>;
+      windowDays: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "The caller's plays and time played in this game";
+      readonly tags: readonly ["catalog"];
+    };
+  }, {
+    user: {
+      id: number;
+      username: string;
+      guest: boolean;
+      role: "" | "admin";
+      avatar: string;
+      chatLock: boolean;
+      mutedUntil: number;
+      suspendedUntil: number;
+    };
+    clientId: string;
+  }, {
+    slug: z.ZodString;
+  }, {}>;
+  getGamePlayerCounts: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/catalog/players";
+    readonly response: z.ZodObject<{
+      games: z.ZodRecord<z.ZodString, z.ZodObject<{
+        accounts: z.ZodNumber;
+        guests: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly doc: {
+      readonly summary: "How many accounts and guests have each game open right now (counts only)";
+      readonly tags: readonly ["catalog"];
+    };
+  }, {
+    user: SessionUser | null;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
 };
 //#endregion
 //#region src/api/daily.d.ts
@@ -2373,6 +2529,34 @@ export declare const ChatLineEvent: z.ZodObject<{
 /** The error codes a chat send can fail with (besides its surface's own). */
 export declare const CHAT_ERRORS: readonly ["rate_limited", "content_rejected", "bad_quick"];
 //#endregion
+//#region src/api/mp/invite-links.d.ts
+/** An invite link's token (base64url). */
+export declare const InviteLinkToken: z.ZodString;
+/** A live invite link. */
+export declare const InviteLink: z.ZodObject<{
+  token: z.ZodString;
+  url: z.ZodString;
+  game: z.ZodString;
+  mode: z.ZodOptional<z.ZodString>;
+  room: z.ZodString;
+  createdBy: z.ZodNumber;
+  expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+/** An invite link. */
+export type InviteLink = z.infer<typeof InviteLink>;
+/** `:token` of an invite link. */
+export declare const InviteLinkParams: z.ZodObject<{
+  token: z.ZodString;
+}, z.core.$strip>;
+/** `POST /mp/links` body: a link to the room I'm in, in this game. */
+export declare const InviteLinkCreate: z.ZodObject<{
+  game: z.ZodString;
+}, z.core.$strip>;
+/** `GET /mp/links` query: my links in a game (and the links to rooms I host). */
+export declare const InviteLinkQuery: z.ZodObject<{
+  game: z.ZodString;
+}, z.core.$strip>;
+//#endregion
 //#region src/api/mp/parties.d.ts
 /** A game mode key, as the game's `multiplayer.modes[].key` declares it: `[A-Za-z0-9_-]{1,32}`. */
 export declare const GameMode: z.ZodString;
@@ -2491,6 +2675,21 @@ export declare const Launch: z.ZodObject<{
     avatar: z.ZodString;
     guest: z.ZodBoolean;
   }, z.core.$strip>>>;
+  via: z.ZodOptional<z.ZodEnum<{
+    link: "link";
+    rejoin: "rejoin";
+  }>>;
+  tournament: z.ZodOptional<z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodString;
+    match: z.ZodString;
+    opponent: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 /** A launch. */
 export type Launch = z.infer<typeof Launch>;
@@ -2799,9 +2998,9 @@ export type RaceRecord = z.infer<typeof RaceRecord>;
 export declare const RoomCode: z.ZodString;
 /** A room's lifecycle: new players join only in the lobby. */
 export declare const RoomPhase: z.ZodEnum<{
+  ended: "ended";
   lobby: "lobby";
   playing: "playing";
-  ended: "ended";
 }>;
 /**
  * Who hears a send. `host` (default): guests' unaddressed sends reach the
@@ -2812,6 +3011,17 @@ export declare const RoomModel: z.ZodEnum<{
   host: "host";
   relay: "relay";
 }>;
+/**
+ * When the host role moves on mid-game. `grace` (default): only once the
+ * host's seat is freed (they left, or their reconnect grace ran out), so a
+ * host whose browser holds hidden state can come back and carry on. `drop`:
+ * as soon as the host drops, for games whose whole truth is in the shared
+ * state, so the match never waits.
+ */
+export declare const HostMigration: z.ZodEnum<{
+  grace: "grace";
+  drop: "drop";
+}>;
 /** A seat in a room, keyed by user (any tab of that user reclaims it). */
 export declare const RoomSeat: z.ZodObject<{
   userId: z.ZodNumber;
@@ -2819,6 +3029,7 @@ export declare const RoomSeat: z.ZodObject<{
   avatar: z.ZodString;
   ready: z.ZodBoolean;
   connected: z.ZodBoolean;
+  graceEndsAt: z.ZodOptional<z.ZodNumber>;
   data: z.ZodOptional<z.ZodJSONSchema>;
 }, z.core.$strip>;
 /** The public description of a room (`room` event, room and race acks, the `hello` snapshot). */
@@ -2830,9 +3041,9 @@ export declare const RoomInfo: z.ZodObject<{
   hostId: z.ZodNumber;
   public: z.ZodBoolean;
   phase: z.ZodEnum<{
+    ended: "ended";
     lobby: "lobby";
     playing: "playing";
-    ended: "ended";
   }>;
   maxPlayers: z.ZodNumber;
   model: z.ZodEnum<{
@@ -2845,6 +3056,7 @@ export declare const RoomInfo: z.ZodObject<{
     avatar: z.ZodString;
     ready: z.ZodBoolean;
     connected: z.ZodBoolean;
+    graceEndsAt: z.ZodOptional<z.ZodNumber>;
     data: z.ZodOptional<z.ZodJSONSchema>;
   }, z.core.$strip>>;
   spectators: z.ZodNumber;
@@ -2939,18 +3151,46 @@ export declare const RoomTarget: z.ZodObject<{
 /** Why a room went away for this tab (`room.closed`). */
 export declare const RoomClosedReason: z.ZodEnum<{
   ended: "ended";
-  removed: "removed";
   empty: "empty";
+  removed: "removed";
   host_left: "host_left";
   moved: "moved";
   other_tab: "other_tab";
 }>;
-/** Why a seat was freed (`room.abandoned`). */
+/** Why a seat was freed (`room.abandoned`, `room.seat` `gone`). */
 export declare const SeatGoneReason: z.ZodEnum<{
   left: "left";
   abandoned: "abandoned";
   kicked: "kicked";
 }>;
+/**
+ * What happened to a seat (`room.seat`): `away` (the player dropped; the seat
+ * is held until `graceEndsAt`, so the game can hand it to its computer
+ * player), `back` (they reclaimed it: give control back), `gone` (freed for
+ * good: left, kicked, or the grace ran out).
+ */
+export declare const SeatStatus: z.ZodEnum<{
+  away: "away";
+  back: "back";
+  gone: "gone";
+}>;
+/** A seat change (`room.seat`). */
+export declare const SeatChange: z.ZodObject<{
+  userId: z.ZodNumber;
+  status: z.ZodEnum<{
+    away: "away";
+    back: "back";
+    gone: "gone";
+  }>;
+  graceEndsAt: z.ZodOptional<z.ZodNumber>;
+  reason: z.ZodOptional<z.ZodEnum<{
+    left: "left";
+    abandoned: "abandoned";
+    kicked: "kicked";
+  }>>;
+}, z.core.$strip>;
+/** A seat change. */
+export type SeatChange = z.infer<typeof SeatChange>;
 //#endregion
 //#region src/api/mp/snapshot.d.ts
 /**
@@ -3000,9 +3240,9 @@ export declare const MultiplayerSnapshot: z.ZodObject<{
     hostId: z.ZodNumber;
     public: z.ZodBoolean;
     phase: z.ZodEnum<{
+      ended: "ended";
       lobby: "lobby";
       playing: "playing";
-      ended: "ended";
     }>;
     maxPlayers: z.ZodNumber;
     model: z.ZodEnum<{
@@ -3015,6 +3255,7 @@ export declare const MultiplayerSnapshot: z.ZodObject<{
       avatar: z.ZodString;
       ready: z.ZodBoolean;
       connected: z.ZodBoolean;
+      graceEndsAt: z.ZodOptional<z.ZodNumber>;
       data: z.ZodOptional<z.ZodJSONSchema>;
     }, z.core.$strip>>;
     spectators: z.ZodNumber;
@@ -3169,6 +3410,21 @@ export declare const mpEndpoints: {
           avatar: z.ZodString;
           guest: z.ZodBoolean;
         }, z.core.$strip>>>;
+        via: z.ZodOptional<z.ZodEnum<{
+          link: "link";
+          rejoin: "rejoin";
+        }>>;
+        tournament: z.ZodOptional<z.ZodObject<{
+          id: z.ZodNumber;
+          title: z.ZodString;
+          match: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+        }, z.core.$strip>>;
       }, z.core.$strip>;
     }, z.core.$strip>;
     readonly errors: {
@@ -3184,6 +3440,31 @@ export declare const mpEndpoints: {
     user: SessionUser;
     clientId: string;
   }, {}, import("@ayepi/core").EmptyObject>;
+  openInviteLink: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/mp/links/:token/open";
+    readonly params: z.ZodObject<{
+      token: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      launchToken: z.ZodString;
+      url: z.ZodString;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+      readonly 429: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Open an invite link: a join launch when a seat is free, else a watch launch";
+      readonly tags: readonly ["mp"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
   setPartyJoinInfo: import("@ayepi/core").Endpoint<{
     readonly method: "POST";
     readonly path: "/mp/parties/:id/join-info";
@@ -3378,6 +3659,88 @@ export declare const mpEndpoints: {
     user: SessionUser;
     clientId: string;
   }, {}, import("@ayepi/core").EmptyObject>;
+  createInviteLink: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/mp/links";
+    readonly body: z.ZodObject<{
+      game: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      token: z.ZodString;
+      url: z.ZodString;
+      game: z.ZodString;
+      mode: z.ZodOptional<z.ZodString>;
+      room: z.ZodString;
+      createdBy: z.ZodNumber;
+      expiresAt: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 400: ErrorBodySchema;
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+      readonly 429: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "An invite link to the room I'm in (reused while it lives): anyone who opens it joins, or watches when it's full";
+      readonly tags: readonly ["mp"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  listInviteLinks: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/mp/links";
+    readonly query: z.ZodObject<{
+      game: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      links: z.ZodArray<z.ZodObject<{
+        token: z.ZodString;
+        url: z.ZodString;
+        game: z.ZodString;
+        mode: z.ZodOptional<z.ZodString>;
+        room: z.ZodString;
+        createdBy: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "My live invite links in a game, plus the links to rooms I host";
+      readonly tags: readonly ["mp"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  revokeInviteLink: import("@ayepi/core").Endpoint<{
+    readonly method: "DELETE";
+    readonly path: "/mp/links/:token";
+    readonly params: z.ZodObject<{
+      token: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Revoke an invite link (its creator, or the host of the room it opens)";
+      readonly tags: readonly ["mp"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
   cancelGameInvite: import("@ayepi/core").Endpoint<{
     readonly method: "DELETE";
     readonly path: "/mp/invites/:id";
@@ -4870,9 +5233,9 @@ export declare const FriendChange: z.ZodEnum<{
 export type FriendChange = z.infer<typeof FriendChange>;
 /** My relation to another player, as their card shows it. */
 export declare const Relation: z.ZodEnum<{
+  blocked: "blocked";
   incoming: "incoming";
   outgoing: "outgoing";
-  blocked: "blocked";
   self: "self";
   friend: "friend";
   none: "none";
@@ -4889,9 +5252,9 @@ export declare const PlayerCard: z.ZodObject<{
   avatar: z.ZodString;
   guest: z.ZodBoolean;
   relation: z.ZodEnum<{
+    blocked: "blocked";
     incoming: "incoming";
     outgoing: "outgoing";
-    blocked: "blocked";
     self: "self";
     friend: "friend";
     none: "none";
@@ -5350,9 +5713,9 @@ export declare const socialEndpoints: {
       avatar: z.ZodString;
       guest: z.ZodBoolean;
       relation: z.ZodEnum<{
+        blocked: "blocked";
         incoming: "incoming";
         outgoing: "outgoing";
-        blocked: "blocked";
         self: "self";
         friend: "friend";
         none: "none";
@@ -5407,9 +5770,9 @@ export declare const socialEndpoints: {
       avatar: z.ZodString;
       guest: z.ZodBoolean;
       relation: z.ZodEnum<{
+        blocked: "blocked";
         incoming: "incoming";
         outgoing: "outgoing";
-        blocked: "blocked";
         self: "self";
         friend: "friend";
         none: "none";
@@ -5550,22 +5913,1960 @@ export declare const socialEndpoints: {
   }, {}, import("@ayepi/core").EmptyObject>;
 };
 //#endregion
-//#region src/api/version.d.ts
-/**
- * A semver range in the npm form: comparators (`>=2.0.0-0`, `<3.0.0`)
- * separated by spaces are all required; `||` separates alternatives.
- */
-export declare const VersionRange: z.ZodString;
-/** What `GET /version` answers. */
-export declare const HubVersion: z.ZodObject<{
-  server: z.ZodString;
-  contract: z.ZodString;
-  supported: z.ZodString;
-  deprecated: z.ZodString;
-}, z.core.$strip>;
-/** The hub's version and the client versions it supports. */
-export type HubVersion = z.infer<typeof HubVersion>;
-/** The version endpoints. */
+//#region src/api/tournaments/shapes.d.ts
+/** A tournament's id. */
+export declare const TournamentId: z.ZodNumber;
+/** `open`: listed, anyone can sign up or follow. `closed`: only invited players see it. */
+export declare const TournamentVisibility: z.ZodEnum<{
+  open: "open";
+  closed: "closed";
+}>;
+/** How the bracket is seeded: by each player's wins in the tournament's games, or at random. */
+export declare const TournamentSeeding: z.ZodEnum<{
+  rank: "rank";
+  random: "random";
+}>;
+/** Which game each match is: the one game, one random pick from the set for the whole tournament, or a random pick per match. */
+export declare const TournamentGamePick: z.ZodEnum<{
+  fixed: "fixed";
+  "random-once": "random-once";
+  "random-each": "random-each";
+}>;
+/** When a tournament starts: at a set time (with whoever signed up), or as soon as `minPlayers` sign up. */
+export declare const TournamentStart: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"scheduled">;
+  at: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"filled">;
+}, z.core.$strip>], "kind">;
+/** When a tournament starts. */
+export type TournamentStart = z.infer<typeof TournamentStart>;
+/** `signup` → `running` → `done`; or `cancelled` (by its creator, or too few players at the start). */
+export declare const TournamentPhase: z.ZodEnum<{
+  done: "done";
+  cancelled: "cancelled";
+  signup: "signup";
+  running: "running";
+}>;
+/** A tournament's phase. */
+export type TournamentPhase = z.infer<typeof TournamentPhase>;
+/** Where a match sits: the winners bracket, a redemption bracket (players with losses), or the final ladder. */
+export declare const TournamentStage: z.ZodEnum<{
+  winners: "winners";
+  redemption: "redemption";
+  final: "final";
+}>;
+/** How a match was decided. */
+export declare const TournamentDecision: z.ZodEnum<{
+  forfeit: "forfeit";
+  timeout: "timeout";
+  withdrawn: "withdrawn";
+  played: "played";
+  bye: "bye";
+}>;
+/** How a match was decided. */
+export type TournamentDecision = z.infer<typeof TournamentDecision>;
+/** `POST /tournaments`. Everything but `games` has a default: the quick "public 1v1, single elimination". */
+export declare const TournamentCreate: z.ZodObject<{
+  title: z.ZodOptional<z.ZodString>;
+  games: z.ZodArray<z.ZodString>;
+  pick: z.ZodDefault<z.ZodEnum<{
+    fixed: "fixed";
+    "random-once": "random-once";
+    "random-each": "random-each";
+  }>>;
+  lives: z.ZodDefault<z.ZodNumber>;
+  seeding: z.ZodDefault<z.ZodEnum<{
+    rank: "rank";
+    random: "random";
+  }>>;
+  visibility: z.ZodDefault<z.ZodEnum<{
+    open: "open";
+    closed: "closed";
+  }>>;
+  start: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"scheduled">;
+    at: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"filled">;
+  }, z.core.$strip>], "kind">>;
+  minPlayers: z.ZodDefault<z.ZodNumber>;
+  maxPlayers: z.ZodDefault<z.ZodNumber>;
+  readyMinutes: z.ZodDefault<z.ZodNumber>;
+  invite: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+/** What creating a tournament takes. */
+export type TournamentCreate = z.output<typeof TournamentCreate>;
+/** One entrant, as the bracket shows them. */
+export declare const TournamentPlayer: z.ZodObject<{
+  user: z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>;
+  seed: z.ZodNullable<z.ZodNumber>;
+  wins: z.ZodNumber;
+  losses: z.ZodNumber;
+  out: z.ZodBoolean;
+}, z.core.$strip>;
+/** One entrant. */
+export type TournamentPlayer = z.infer<typeof TournamentPlayer>;
+/** One match in the bracket. Sides are user ids (see the detail's `players`). */
+export declare const TournamentMatch: z.ZodObject<{
+  id: z.ZodString;
+  stage: z.ZodEnum<{
+    winners: "winners";
+    redemption: "redemption";
+    final: "final";
+  }>;
+  level: z.ZodNumber;
+  round: z.ZodNumber;
+  slot: z.ZodNumber;
+  a: z.ZodNullable<z.ZodNumber>;
+  b: z.ZodNullable<z.ZodNumber>;
+  status: z.ZodEnum<{
+    ready: "ready";
+    waiting: "waiting";
+    done: "done";
+  }>;
+  winnerId: z.ZodNullable<z.ZodNumber>;
+  decision: z.ZodNullable<z.ZodEnum<{
+    forfeit: "forfeit";
+    timeout: "timeout";
+    withdrawn: "withdrawn";
+    played: "played";
+    bye: "bye";
+  }>>;
+  game: z.ZodNullable<z.ZodString>;
+  deadlineAt: z.ZodNullable<z.ZodNumber>;
+  started: z.ZodBoolean;
+}, z.core.$strip>;
+/** One match. */
+export type TournamentMatch = z.infer<typeof TournamentMatch>;
+/** A ready match of mine: who against, in which game, and until when. */
+export declare const MyTournamentMatch: z.ZodObject<{
+  id: z.ZodString;
+  opponent: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>>;
+  game: z.ZodString;
+  gameTitle: z.ZodString;
+  deadlineAt: z.ZodNumber;
+  started: z.ZodBoolean;
+}, z.core.$strip>;
+/** A ready match of mine. */
+export type MyTournamentMatch = z.infer<typeof MyTournamentMatch>;
+/** The viewer's own relation to a tournament. */
+export declare const TournamentMe: z.ZodObject<{
+  joined: z.ZodBoolean;
+  invited: z.ZodBoolean;
+  following: z.ZodBoolean;
+  leadMinutes: z.ZodNullable<z.ZodNumber>;
+  isCreator: z.ZodBoolean;
+  stillIn: z.ZodBoolean;
+  nextMatch: z.ZodNullable<z.ZodObject<{
+    id: z.ZodString;
+    opponent: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    game: z.ZodString;
+    gameTitle: z.ZodString;
+    deadlineAt: z.ZodNumber;
+    started: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** A tournament in lists. */
+export declare const TournamentSummary: z.ZodObject<{
+  id: z.ZodNumber;
+  title: z.ZodString;
+  creator: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>>;
+  visibility: z.ZodEnum<{
+    open: "open";
+    closed: "closed";
+  }>;
+  phase: z.ZodEnum<{
+    done: "done";
+    cancelled: "cancelled";
+    signup: "signup";
+    running: "running";
+  }>;
+  games: z.ZodArray<z.ZodString>;
+  pick: z.ZodEnum<{
+    fixed: "fixed";
+    "random-once": "random-once";
+    "random-each": "random-each";
+  }>;
+  game: z.ZodNullable<z.ZodString>;
+  gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+  lives: z.ZodNumber;
+  seeding: z.ZodEnum<{
+    rank: "rank";
+    random: "random";
+  }>;
+  start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"scheduled">;
+    at: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"filled">;
+  }, z.core.$strip>], "kind">;
+  minPlayers: z.ZodNumber;
+  maxPlayers: z.ZodNumber;
+  readyMinutes: z.ZodNumber;
+  entrants: z.ZodNumber;
+  createdAt: z.ZodNumber;
+  startedAt: z.ZodNullable<z.ZodNumber>;
+  endedAt: z.ZodNullable<z.ZodNumber>;
+  champion: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>>;
+  me: z.ZodObject<{
+    joined: z.ZodBoolean;
+    invited: z.ZodBoolean;
+    following: z.ZodBoolean;
+    leadMinutes: z.ZodNullable<z.ZodNumber>;
+    isCreator: z.ZodBoolean;
+    stillIn: z.ZodBoolean;
+    nextMatch: z.ZodNullable<z.ZodObject<{
+      id: z.ZodString;
+      opponent: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      game: z.ZodString;
+      gameTitle: z.ZodString;
+      deadlineAt: z.ZodNumber;
+      started: z.ZodBoolean;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/** A tournament in lists. */
+export type TournamentSummary = z.infer<typeof TournamentSummary>;
+/** A tournament with its players and bracket. */
+export declare const TournamentDetail: z.ZodObject<{
+  id: z.ZodNumber;
+  title: z.ZodString;
+  creator: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>>;
+  visibility: z.ZodEnum<{
+    open: "open";
+    closed: "closed";
+  }>;
+  phase: z.ZodEnum<{
+    done: "done";
+    cancelled: "cancelled";
+    signup: "signup";
+    running: "running";
+  }>;
+  games: z.ZodArray<z.ZodString>;
+  pick: z.ZodEnum<{
+    fixed: "fixed";
+    "random-once": "random-once";
+    "random-each": "random-each";
+  }>;
+  game: z.ZodNullable<z.ZodString>;
+  gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+  lives: z.ZodNumber;
+  seeding: z.ZodEnum<{
+    rank: "rank";
+    random: "random";
+  }>;
+  start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"scheduled">;
+    at: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"filled">;
+  }, z.core.$strip>], "kind">;
+  minPlayers: z.ZodNumber;
+  maxPlayers: z.ZodNumber;
+  readyMinutes: z.ZodNumber;
+  entrants: z.ZodNumber;
+  createdAt: z.ZodNumber;
+  startedAt: z.ZodNullable<z.ZodNumber>;
+  endedAt: z.ZodNullable<z.ZodNumber>;
+  champion: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>>;
+  me: z.ZodObject<{
+    joined: z.ZodBoolean;
+    invited: z.ZodBoolean;
+    following: z.ZodBoolean;
+    leadMinutes: z.ZodNullable<z.ZodNumber>;
+    isCreator: z.ZodBoolean;
+    stillIn: z.ZodBoolean;
+    nextMatch: z.ZodNullable<z.ZodObject<{
+      id: z.ZodString;
+      opponent: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      game: z.ZodString;
+      gameTitle: z.ZodString;
+      deadlineAt: z.ZodNumber;
+      started: z.ZodBoolean;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  players: z.ZodArray<z.ZodObject<{
+    user: z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>;
+    seed: z.ZodNullable<z.ZodNumber>;
+    wins: z.ZodNumber;
+    losses: z.ZodNumber;
+    out: z.ZodBoolean;
+  }, z.core.$strip>>;
+  matches: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    stage: z.ZodEnum<{
+      winners: "winners";
+      redemption: "redemption";
+      final: "final";
+    }>;
+    level: z.ZodNumber;
+    round: z.ZodNumber;
+    slot: z.ZodNumber;
+    a: z.ZodNullable<z.ZodNumber>;
+    b: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<{
+      ready: "ready";
+      waiting: "waiting";
+      done: "done";
+    }>;
+    winnerId: z.ZodNullable<z.ZodNumber>;
+    decision: z.ZodNullable<z.ZodEnum<{
+      forfeit: "forfeit";
+      timeout: "timeout";
+      withdrawn: "withdrawn";
+      played: "played";
+      bye: "bye";
+    }>>;
+    game: z.ZodNullable<z.ZodString>;
+    deadlineAt: z.ZodNullable<z.ZodNumber>;
+    started: z.ZodBoolean;
+  }, z.core.$strip>>;
+  inviteUrl: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** A tournament with its bracket. */
+export type TournamentDetail = z.infer<typeof TournamentDetail>;
+/** What a launch into a tournament match carries (`launch.tournament`). */
+export declare const TournamentLaunch: z.ZodObject<{
+  id: z.ZodNumber;
+  title: z.ZodString;
+  match: z.ZodString;
+  opponent: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** What a launch into a tournament match carries. */
+export type TournamentLaunch = z.infer<typeof TournamentLaunch>;
+//#endregion
+//#region src/api/tournaments/endpoints.d.ts
+/** `GET /tournaments` filters. */
+export declare const TournamentListQuery: z.ZodObject<{
+  game: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+}, z.core.$strip>;
+/** The tournament endpoints. */
+export declare const tournamentEndpoints: {
+  joinTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/tournaments/:id/join";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      id: z.ZodNumber;
+      title: z.ZodString;
+      creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      visibility: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: z.ZodNullable<z.ZodString>;
+      gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+      lives: z.ZodNumber;
+      seeding: z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">;
+      minPlayers: z.ZodNumber;
+      maxPlayers: z.ZodNumber;
+      readyMinutes: z.ZodNumber;
+      entrants: z.ZodNumber;
+      createdAt: z.ZodNumber;
+      startedAt: z.ZodNullable<z.ZodNumber>;
+      endedAt: z.ZodNullable<z.ZodNumber>;
+      champion: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      me: z.ZodObject<{
+        joined: z.ZodBoolean;
+        invited: z.ZodBoolean;
+        following: z.ZodBoolean;
+        leadMinutes: z.ZodNullable<z.ZodNumber>;
+        isCreator: z.ZodBoolean;
+        stillIn: z.ZodBoolean;
+        nextMatch: z.ZodNullable<z.ZodObject<{
+          id: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+          game: z.ZodString;
+          gameTitle: z.ZodString;
+          deadlineAt: z.ZodNumber;
+          started: z.ZodBoolean;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      players: z.ZodArray<z.ZodObject<{
+        user: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        seed: z.ZodNullable<z.ZodNumber>;
+        wins: z.ZodNumber;
+        losses: z.ZodNumber;
+        out: z.ZodBoolean;
+      }, z.core.$strip>>;
+      matches: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+          winners: "winners";
+          redemption: "redemption";
+          final: "final";
+        }>;
+        level: z.ZodNumber;
+        round: z.ZodNumber;
+        slot: z.ZodNumber;
+        a: z.ZodNullable<z.ZodNumber>;
+        b: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+          ready: "ready";
+          waiting: "waiting";
+          done: "done";
+        }>;
+        winnerId: z.ZodNullable<z.ZodNumber>;
+        decision: z.ZodNullable<z.ZodEnum<{
+          forfeit: "forfeit";
+          timeout: "timeout";
+          withdrawn: "withdrawn";
+          played: "played";
+          bye: "bye";
+        }>>;
+        game: z.ZodNullable<z.ZodString>;
+        deadlineAt: z.ZodNullable<z.ZodNumber>;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+      inviteUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+      readonly 429: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Sign up (open tournaments, or closed ones I was invited to or have the link for)";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  leaveTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/tournaments/:id/leave";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      id: z.ZodNumber;
+      title: z.ZodString;
+      creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      visibility: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: z.ZodNullable<z.ZodString>;
+      gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+      lives: z.ZodNumber;
+      seeding: z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">;
+      minPlayers: z.ZodNumber;
+      maxPlayers: z.ZodNumber;
+      readyMinutes: z.ZodNumber;
+      entrants: z.ZodNumber;
+      createdAt: z.ZodNumber;
+      startedAt: z.ZodNullable<z.ZodNumber>;
+      endedAt: z.ZodNullable<z.ZodNumber>;
+      champion: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      me: z.ZodObject<{
+        joined: z.ZodBoolean;
+        invited: z.ZodBoolean;
+        following: z.ZodBoolean;
+        leadMinutes: z.ZodNullable<z.ZodNumber>;
+        isCreator: z.ZodBoolean;
+        stillIn: z.ZodBoolean;
+        nextMatch: z.ZodNullable<z.ZodObject<{
+          id: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+          game: z.ZodString;
+          gameTitle: z.ZodString;
+          deadlineAt: z.ZodNumber;
+          started: z.ZodBoolean;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      players: z.ZodArray<z.ZodObject<{
+        user: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        seed: z.ZodNullable<z.ZodNumber>;
+        wins: z.ZodNumber;
+        losses: z.ZodNumber;
+        out: z.ZodBoolean;
+      }, z.core.$strip>>;
+      matches: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+          winners: "winners";
+          redemption: "redemption";
+          final: "final";
+        }>;
+        level: z.ZodNumber;
+        round: z.ZodNumber;
+        slot: z.ZodNumber;
+        a: z.ZodNullable<z.ZodNumber>;
+        b: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+          ready: "ready";
+          waiting: "waiting";
+          done: "done";
+        }>;
+        winnerId: z.ZodNullable<z.ZodNumber>;
+        decision: z.ZodNullable<z.ZodEnum<{
+          forfeit: "forfeit";
+          timeout: "timeout";
+          withdrawn: "withdrawn";
+          played: "played";
+          bye: "bye";
+        }>>;
+        game: z.ZodNullable<z.ZodString>;
+        deadlineAt: z.ZodNullable<z.ZodNumber>;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+      inviteUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Drop out: before the start my place is freed; after it I forfeit what is left";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  launchTournamentMatch: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/tournaments/:id/matches/:match/launch";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+      match: z.ZodString;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      launchToken: z.ZodString;
+      url: z.ZodString;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "A launch into my ready match: host for the better seed, guest for the other";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  createTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/tournaments";
+    readonly body: z.ZodObject<{
+      title: z.ZodOptional<z.ZodString>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodDefault<z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>>;
+      lives: z.ZodDefault<z.ZodNumber>;
+      seeding: z.ZodDefault<z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>>;
+      visibility: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>>;
+      start: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">>;
+      minPlayers: z.ZodDefault<z.ZodNumber>;
+      maxPlayers: z.ZodDefault<z.ZodNumber>;
+      readyMinutes: z.ZodDefault<z.ZodNumber>;
+      invite: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      id: z.ZodNumber;
+      title: z.ZodString;
+      creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      visibility: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: z.ZodNullable<z.ZodString>;
+      gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+      lives: z.ZodNumber;
+      seeding: z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">;
+      minPlayers: z.ZodNumber;
+      maxPlayers: z.ZodNumber;
+      readyMinutes: z.ZodNumber;
+      entrants: z.ZodNumber;
+      createdAt: z.ZodNumber;
+      startedAt: z.ZodNullable<z.ZodNumber>;
+      endedAt: z.ZodNullable<z.ZodNumber>;
+      champion: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      me: z.ZodObject<{
+        joined: z.ZodBoolean;
+        invited: z.ZodBoolean;
+        following: z.ZodBoolean;
+        leadMinutes: z.ZodNullable<z.ZodNumber>;
+        isCreator: z.ZodBoolean;
+        stillIn: z.ZodBoolean;
+        nextMatch: z.ZodNullable<z.ZodObject<{
+          id: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+          game: z.ZodString;
+          gameTitle: z.ZodString;
+          deadlineAt: z.ZodNumber;
+          started: z.ZodBoolean;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      players: z.ZodArray<z.ZodObject<{
+        user: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        seed: z.ZodNullable<z.ZodNumber>;
+        wins: z.ZodNumber;
+        losses: z.ZodNumber;
+        out: z.ZodBoolean;
+      }, z.core.$strip>>;
+      matches: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+          winners: "winners";
+          redemption: "redemption";
+          final: "final";
+        }>;
+        level: z.ZodNumber;
+        round: z.ZodNumber;
+        slot: z.ZodNumber;
+        a: z.ZodNullable<z.ZodNumber>;
+        b: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+          ready: "ready";
+          waiting: "waiting";
+          done: "done";
+        }>;
+        winnerId: z.ZodNullable<z.ZodNumber>;
+        decision: z.ZodNullable<z.ZodEnum<{
+          forfeit: "forfeit";
+          timeout: "timeout";
+          withdrawn: "withdrawn";
+          played: "played";
+          bye: "bye";
+        }>>;
+        game: z.ZodNullable<z.ZodString>;
+        deadlineAt: z.ZodNullable<z.ZodNumber>;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+      inviteUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 400: ErrorBodySchema;
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 422: ErrorBodySchema;
+      readonly 429: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Create a tournament (I am signed up to it); the title goes through the content filter";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  inviteToTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/tournaments/:id/invites";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+      userIds: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      invited: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+      readonly 429: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Creator: invite friends (others are skipped without saying why)";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  followTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "PUT";
+    readonly path: "/tournaments/:id/follow";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly body: z.ZodObject<{
+      leadMinutes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      id: z.ZodNumber;
+      title: z.ZodString;
+      creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      visibility: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: z.ZodNullable<z.ZodString>;
+      gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+      lives: z.ZodNumber;
+      seeding: z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">;
+      minPlayers: z.ZodNumber;
+      maxPlayers: z.ZodNumber;
+      readyMinutes: z.ZodNumber;
+      entrants: z.ZodNumber;
+      createdAt: z.ZodNumber;
+      startedAt: z.ZodNullable<z.ZodNumber>;
+      endedAt: z.ZodNullable<z.ZodNumber>;
+      champion: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      me: z.ZodObject<{
+        joined: z.ZodBoolean;
+        invited: z.ZodBoolean;
+        following: z.ZodBoolean;
+        leadMinutes: z.ZodNullable<z.ZodNumber>;
+        isCreator: z.ZodBoolean;
+        stillIn: z.ZodBoolean;
+        nextMatch: z.ZodNullable<z.ZodObject<{
+          id: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+          game: z.ZodString;
+          gameTitle: z.ZodString;
+          deadlineAt: z.ZodNumber;
+          started: z.ZodBoolean;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Follow a tournament (hear when it opens, starts and ends); leadMinutes: remind me that long before a scheduled start (absent: no reminder)";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  unfollowTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "DELETE";
+    readonly path: "/tournaments/:id/follow";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Stop following a tournament";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  startTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "POST";
+    readonly path: "/tournaments/:id/start";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      id: z.ZodNumber;
+      title: z.ZodString;
+      creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      visibility: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: z.ZodNullable<z.ZodString>;
+      gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+      lives: z.ZodNumber;
+      seeding: z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">;
+      minPlayers: z.ZodNumber;
+      maxPlayers: z.ZodNumber;
+      readyMinutes: z.ZodNumber;
+      entrants: z.ZodNumber;
+      createdAt: z.ZodNumber;
+      startedAt: z.ZodNullable<z.ZodNumber>;
+      endedAt: z.ZodNullable<z.ZodNumber>;
+      champion: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      me: z.ZodObject<{
+        joined: z.ZodBoolean;
+        invited: z.ZodBoolean;
+        following: z.ZodBoolean;
+        leadMinutes: z.ZodNullable<z.ZodNumber>;
+        isCreator: z.ZodBoolean;
+        stillIn: z.ZodBoolean;
+        nextMatch: z.ZodNullable<z.ZodObject<{
+          id: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+          game: z.ZodString;
+          gameTitle: z.ZodString;
+          deadlineAt: z.ZodNumber;
+          started: z.ZodBoolean;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      players: z.ZodArray<z.ZodObject<{
+        user: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        seed: z.ZodNullable<z.ZodNumber>;
+        wins: z.ZodNumber;
+        losses: z.ZodNumber;
+        out: z.ZodBoolean;
+      }, z.core.$strip>>;
+      matches: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+          winners: "winners";
+          redemption: "redemption";
+          final: "final";
+        }>;
+        level: z.ZodNumber;
+        round: z.ZodNumber;
+        slot: z.ZodNumber;
+        a: z.ZodNullable<z.ZodNumber>;
+        b: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+          ready: "ready";
+          waiting: "waiting";
+          done: "done";
+        }>;
+        winnerId: z.ZodNullable<z.ZodNumber>;
+        decision: z.ZodNullable<z.ZodEnum<{
+          forfeit: "forfeit";
+          timeout: "timeout";
+          withdrawn: "withdrawn";
+          played: "played";
+          bye: "bye";
+        }>>;
+        game: z.ZodNullable<z.ZodString>;
+        deadlineAt: z.ZodNullable<z.ZodNumber>;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+      inviteUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Creator: start now with whoever signed up (at least two)";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  cancelTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "DELETE";
+    readonly path: "/tournaments/:id";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      ok: z.ZodLiteral<true>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 401: ErrorBodySchema;
+      readonly 403: ErrorBodySchema;
+      readonly 404: ErrorBodySchema;
+      readonly 409: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "Creator (or an admin): cancel a tournament that has not finished";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  listTournaments: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/tournaments";
+    readonly query: z.ZodObject<{
+      game: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"">, z.ZodString]>>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      tournaments: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        creator: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        visibility: z.ZodEnum<{
+          open: "open";
+          closed: "closed";
+        }>;
+        phase: z.ZodEnum<{
+          done: "done";
+          cancelled: "cancelled";
+          signup: "signup";
+          running: "running";
+        }>;
+        games: z.ZodArray<z.ZodString>;
+        pick: z.ZodEnum<{
+          fixed: "fixed";
+          "random-once": "random-once";
+          "random-each": "random-each";
+        }>;
+        game: z.ZodNullable<z.ZodString>;
+        gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+        lives: z.ZodNumber;
+        seeding: z.ZodEnum<{
+          rank: "rank";
+          random: "random";
+        }>;
+        start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"scheduled">;
+          at: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"filled">;
+        }, z.core.$strip>], "kind">;
+        minPlayers: z.ZodNumber;
+        maxPlayers: z.ZodNumber;
+        readyMinutes: z.ZodNumber;
+        entrants: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        startedAt: z.ZodNullable<z.ZodNumber>;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        champion: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        me: z.ZodObject<{
+          joined: z.ZodBoolean;
+          invited: z.ZodBoolean;
+          following: z.ZodBoolean;
+          leadMinutes: z.ZodNullable<z.ZodNumber>;
+          isCreator: z.ZodBoolean;
+          stillIn: z.ZodBoolean;
+          nextMatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            opponent: z.ZodNullable<z.ZodObject<{
+              id: z.ZodNumber;
+              username: z.ZodString;
+              avatar: z.ZodString;
+              guest: z.ZodBoolean;
+            }, z.core.$strip>>;
+            game: z.ZodString;
+            gameTitle: z.ZodString;
+            deadlineAt: z.ZodNumber;
+            started: z.ZodBoolean;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly doc: {
+      readonly summary: "Open tournaments plus the ones I am in, invited to or follow, soonest first";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser | null;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+  getTournament: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/tournaments/:id";
+    readonly params: z.ZodObject<{
+      id: z.ZodCoercedNumber<unknown>;
+    }, z.core.$strip>;
+    readonly query: z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly response: z.ZodObject<{
+      id: z.ZodNumber;
+      title: z.ZodString;
+      creator: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      visibility: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: z.ZodArray<z.ZodString>;
+      pick: z.ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: z.ZodNullable<z.ZodString>;
+      gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+      lives: z.ZodNumber;
+      seeding: z.ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scheduled">;
+        at: z.ZodNumber;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filled">;
+      }, z.core.$strip>], "kind">;
+      minPlayers: z.ZodNumber;
+      maxPlayers: z.ZodNumber;
+      readyMinutes: z.ZodNumber;
+      entrants: z.ZodNumber;
+      createdAt: z.ZodNumber;
+      startedAt: z.ZodNullable<z.ZodNumber>;
+      endedAt: z.ZodNullable<z.ZodNumber>;
+      champion: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        username: z.ZodString;
+        avatar: z.ZodString;
+        guest: z.ZodBoolean;
+      }, z.core.$strip>>;
+      me: z.ZodObject<{
+        joined: z.ZodBoolean;
+        invited: z.ZodBoolean;
+        following: z.ZodBoolean;
+        leadMinutes: z.ZodNullable<z.ZodNumber>;
+        isCreator: z.ZodBoolean;
+        stillIn: z.ZodBoolean;
+        nextMatch: z.ZodNullable<z.ZodObject<{
+          id: z.ZodString;
+          opponent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            username: z.ZodString;
+            avatar: z.ZodString;
+            guest: z.ZodBoolean;
+          }, z.core.$strip>>;
+          game: z.ZodString;
+          gameTitle: z.ZodString;
+          deadlineAt: z.ZodNumber;
+          started: z.ZodBoolean;
+        }, z.core.$strip>>;
+      }, z.core.$strip>;
+      players: z.ZodArray<z.ZodObject<{
+        user: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        seed: z.ZodNullable<z.ZodNumber>;
+        wins: z.ZodNumber;
+        losses: z.ZodNumber;
+        out: z.ZodBoolean;
+      }, z.core.$strip>>;
+      matches: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+          winners: "winners";
+          redemption: "redemption";
+          final: "final";
+        }>;
+        level: z.ZodNumber;
+        round: z.ZodNumber;
+        slot: z.ZodNumber;
+        a: z.ZodNullable<z.ZodNumber>;
+        b: z.ZodNullable<z.ZodNumber>;
+        status: z.ZodEnum<{
+          ready: "ready";
+          waiting: "waiting";
+          done: "done";
+        }>;
+        winnerId: z.ZodNullable<z.ZodNumber>;
+        decision: z.ZodNullable<z.ZodEnum<{
+          forfeit: "forfeit";
+          timeout: "timeout";
+          withdrawn: "withdrawn";
+          played: "played";
+          bye: "bye";
+        }>>;
+        game: z.ZodNullable<z.ZodString>;
+        deadlineAt: z.ZodNullable<z.ZodNumber>;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+      inviteUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    readonly errors: {
+      readonly 404: ErrorBodySchema;
+    };
+    readonly doc: {
+      readonly summary: "A tournament with its players and bracket (404 for a closed one not shared with me)";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser | null;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+};
+//#endregion
+//#region src/api/tournaments/play-online.d.ts
+/** A public lobby or race waiting for players right now. */
+export declare const OpenLobbyEntry: z.ZodObject<{
+  host: z.ZodObject<{
+    id: z.ZodNumber;
+    username: z.ZodString;
+    avatar: z.ZodString;
+    guest: z.ZodBoolean;
+  }, z.core.$strip>;
+  game: z.ZodString;
+  gameTitle: z.ZodString;
+  mode: z.ZodOptional<z.ZodString>;
+  openSeats: z.ZodNumber;
+  since: z.ZodNumber;
+}, z.core.$strip>;
+/** A public lobby or race waiting for players. */
+export type OpenLobbyEntry = z.infer<typeof OpenLobbyEntry>;
+/** The counts on the home card. */
+export declare const PlayOnlineCounts: z.ZodObject<{
+  now: z.ZodNumber;
+  invites: z.ZodNumber;
+  mine: z.ZodNumber;
+  upcoming: z.ZodNumber;
+}, z.core.$strip>;
+/** The counts on the home card. */
+export type PlayOnlineCounts = z.infer<typeof PlayOnlineCounts>;
+/** Everything playable online for the viewer. */
+export declare const PlayOnline: z.ZodObject<{
+  counts: z.ZodObject<{
+    now: z.ZodNumber;
+    invites: z.ZodNumber;
+    mine: z.ZodNumber;
+    upcoming: z.ZodNumber;
+  }, z.core.$strip>;
+  lobbies: z.ZodArray<z.ZodObject<{
+    host: z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>;
+    game: z.ZodString;
+    gameTitle: z.ZodString;
+    mode: z.ZodOptional<z.ZodString>;
+    openSeats: z.ZodNumber;
+    since: z.ZodNumber;
+  }, z.core.$strip>>;
+  gameInvites: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>;
+    to: z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>;
+    game: z.ZodString;
+    gameTitle: z.ZodString;
+    mode: z.ZodOptional<z.ZodString>;
+    partyId: z.ZodString;
+    expiresAt: z.ZodNumber;
+  }, z.core.$strip>>;
+  tournamentInvites: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodString;
+    creator: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    visibility: z.ZodEnum<{
+      open: "open";
+      closed: "closed";
+    }>;
+    phase: z.ZodEnum<{
+      done: "done";
+      cancelled: "cancelled";
+      signup: "signup";
+      running: "running";
+    }>;
+    games: z.ZodArray<z.ZodString>;
+    pick: z.ZodEnum<{
+      fixed: "fixed";
+      "random-once": "random-once";
+      "random-each": "random-each";
+    }>;
+    game: z.ZodNullable<z.ZodString>;
+    gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+    lives: z.ZodNumber;
+    seeding: z.ZodEnum<{
+      rank: "rank";
+      random: "random";
+    }>;
+    start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"scheduled">;
+      at: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"filled">;
+    }, z.core.$strip>], "kind">;
+    minPlayers: z.ZodNumber;
+    maxPlayers: z.ZodNumber;
+    readyMinutes: z.ZodNumber;
+    entrants: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    startedAt: z.ZodNullable<z.ZodNumber>;
+    endedAt: z.ZodNullable<z.ZodNumber>;
+    champion: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    me: z.ZodObject<{
+      joined: z.ZodBoolean;
+      invited: z.ZodBoolean;
+      following: z.ZodBoolean;
+      leadMinutes: z.ZodNullable<z.ZodNumber>;
+      isCreator: z.ZodBoolean;
+      stillIn: z.ZodBoolean;
+      nextMatch: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        opponent: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        game: z.ZodString;
+        gameTitle: z.ZodString;
+        deadlineAt: z.ZodNumber;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  mine: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodString;
+    creator: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    visibility: z.ZodEnum<{
+      open: "open";
+      closed: "closed";
+    }>;
+    phase: z.ZodEnum<{
+      done: "done";
+      cancelled: "cancelled";
+      signup: "signup";
+      running: "running";
+    }>;
+    games: z.ZodArray<z.ZodString>;
+    pick: z.ZodEnum<{
+      fixed: "fixed";
+      "random-once": "random-once";
+      "random-each": "random-each";
+    }>;
+    game: z.ZodNullable<z.ZodString>;
+    gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+    lives: z.ZodNumber;
+    seeding: z.ZodEnum<{
+      rank: "rank";
+      random: "random";
+    }>;
+    start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"scheduled">;
+      at: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"filled">;
+    }, z.core.$strip>], "kind">;
+    minPlayers: z.ZodNumber;
+    maxPlayers: z.ZodNumber;
+    readyMinutes: z.ZodNumber;
+    entrants: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    startedAt: z.ZodNullable<z.ZodNumber>;
+    endedAt: z.ZodNullable<z.ZodNumber>;
+    champion: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    me: z.ZodObject<{
+      joined: z.ZodBoolean;
+      invited: z.ZodBoolean;
+      following: z.ZodBoolean;
+      leadMinutes: z.ZodNullable<z.ZodNumber>;
+      isCreator: z.ZodBoolean;
+      stillIn: z.ZodBoolean;
+      nextMatch: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        opponent: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        game: z.ZodString;
+        gameTitle: z.ZodString;
+        deadlineAt: z.ZodNumber;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  upcoming: z.ZodArray<z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodString;
+    creator: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    visibility: z.ZodEnum<{
+      open: "open";
+      closed: "closed";
+    }>;
+    phase: z.ZodEnum<{
+      done: "done";
+      cancelled: "cancelled";
+      signup: "signup";
+      running: "running";
+    }>;
+    games: z.ZodArray<z.ZodString>;
+    pick: z.ZodEnum<{
+      fixed: "fixed";
+      "random-once": "random-once";
+      "random-each": "random-each";
+    }>;
+    game: z.ZodNullable<z.ZodString>;
+    gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+    lives: z.ZodNumber;
+    seeding: z.ZodEnum<{
+      rank: "rank";
+      random: "random";
+    }>;
+    start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"scheduled">;
+      at: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      kind: z.ZodLiteral<"filled">;
+    }, z.core.$strip>], "kind">;
+    minPlayers: z.ZodNumber;
+    maxPlayers: z.ZodNumber;
+    readyMinutes: z.ZodNumber;
+    entrants: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    startedAt: z.ZodNullable<z.ZodNumber>;
+    endedAt: z.ZodNullable<z.ZodNumber>;
+    champion: z.ZodNullable<z.ZodObject<{
+      id: z.ZodNumber;
+      username: z.ZodString;
+      avatar: z.ZodString;
+      guest: z.ZodBoolean;
+    }, z.core.$strip>>;
+    me: z.ZodObject<{
+      joined: z.ZodBoolean;
+      invited: z.ZodBoolean;
+      following: z.ZodBoolean;
+      leadMinutes: z.ZodNullable<z.ZodNumber>;
+      isCreator: z.ZodBoolean;
+      stillIn: z.ZodBoolean;
+      nextMatch: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        opponent: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        game: z.ZodString;
+        gameTitle: z.ZodString;
+        deadlineAt: z.ZodNumber;
+        started: z.ZodBoolean;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Everything playable online for the viewer. */
+export type PlayOnline = z.infer<typeof PlayOnline>;
+/** The play-online endpoint. Signed-out visitors get the open tournaments only. */
+export declare const playOnlineEndpoints: {
+  getPlayOnline: import("@ayepi/core").Endpoint<{
+    readonly method: "GET";
+    readonly path: "/play-online";
+    readonly response: z.ZodObject<{
+      counts: z.ZodObject<{
+        now: z.ZodNumber;
+        invites: z.ZodNumber;
+        mine: z.ZodNumber;
+        upcoming: z.ZodNumber;
+      }, z.core.$strip>;
+      lobbies: z.ZodArray<z.ZodObject<{
+        host: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        game: z.ZodString;
+        gameTitle: z.ZodString;
+        mode: z.ZodOptional<z.ZodString>;
+        openSeats: z.ZodNumber;
+        since: z.ZodNumber;
+      }, z.core.$strip>>;
+      gameInvites: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>;
+        game: z.ZodString;
+        gameTitle: z.ZodString;
+        mode: z.ZodOptional<z.ZodString>;
+        partyId: z.ZodString;
+        expiresAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      tournamentInvites: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        creator: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        visibility: z.ZodEnum<{
+          open: "open";
+          closed: "closed";
+        }>;
+        phase: z.ZodEnum<{
+          done: "done";
+          cancelled: "cancelled";
+          signup: "signup";
+          running: "running";
+        }>;
+        games: z.ZodArray<z.ZodString>;
+        pick: z.ZodEnum<{
+          fixed: "fixed";
+          "random-once": "random-once";
+          "random-each": "random-each";
+        }>;
+        game: z.ZodNullable<z.ZodString>;
+        gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+        lives: z.ZodNumber;
+        seeding: z.ZodEnum<{
+          rank: "rank";
+          random: "random";
+        }>;
+        start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"scheduled">;
+          at: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"filled">;
+        }, z.core.$strip>], "kind">;
+        minPlayers: z.ZodNumber;
+        maxPlayers: z.ZodNumber;
+        readyMinutes: z.ZodNumber;
+        entrants: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        startedAt: z.ZodNullable<z.ZodNumber>;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        champion: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        me: z.ZodObject<{
+          joined: z.ZodBoolean;
+          invited: z.ZodBoolean;
+          following: z.ZodBoolean;
+          leadMinutes: z.ZodNullable<z.ZodNumber>;
+          isCreator: z.ZodBoolean;
+          stillIn: z.ZodBoolean;
+          nextMatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            opponent: z.ZodNullable<z.ZodObject<{
+              id: z.ZodNumber;
+              username: z.ZodString;
+              avatar: z.ZodString;
+              guest: z.ZodBoolean;
+            }, z.core.$strip>>;
+            game: z.ZodString;
+            gameTitle: z.ZodString;
+            deadlineAt: z.ZodNumber;
+            started: z.ZodBoolean;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+      mine: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        creator: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        visibility: z.ZodEnum<{
+          open: "open";
+          closed: "closed";
+        }>;
+        phase: z.ZodEnum<{
+          done: "done";
+          cancelled: "cancelled";
+          signup: "signup";
+          running: "running";
+        }>;
+        games: z.ZodArray<z.ZodString>;
+        pick: z.ZodEnum<{
+          fixed: "fixed";
+          "random-once": "random-once";
+          "random-each": "random-each";
+        }>;
+        game: z.ZodNullable<z.ZodString>;
+        gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+        lives: z.ZodNumber;
+        seeding: z.ZodEnum<{
+          rank: "rank";
+          random: "random";
+        }>;
+        start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"scheduled">;
+          at: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"filled">;
+        }, z.core.$strip>], "kind">;
+        minPlayers: z.ZodNumber;
+        maxPlayers: z.ZodNumber;
+        readyMinutes: z.ZodNumber;
+        entrants: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        startedAt: z.ZodNullable<z.ZodNumber>;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        champion: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        me: z.ZodObject<{
+          joined: z.ZodBoolean;
+          invited: z.ZodBoolean;
+          following: z.ZodBoolean;
+          leadMinutes: z.ZodNullable<z.ZodNumber>;
+          isCreator: z.ZodBoolean;
+          stillIn: z.ZodBoolean;
+          nextMatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            opponent: z.ZodNullable<z.ZodObject<{
+              id: z.ZodNumber;
+              username: z.ZodString;
+              avatar: z.ZodString;
+              guest: z.ZodBoolean;
+            }, z.core.$strip>>;
+            game: z.ZodString;
+            gameTitle: z.ZodString;
+            deadlineAt: z.ZodNumber;
+            started: z.ZodBoolean;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+      upcoming: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodString;
+        creator: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        visibility: z.ZodEnum<{
+          open: "open";
+          closed: "closed";
+        }>;
+        phase: z.ZodEnum<{
+          done: "done";
+          cancelled: "cancelled";
+          signup: "signup";
+          running: "running";
+        }>;
+        games: z.ZodArray<z.ZodString>;
+        pick: z.ZodEnum<{
+          fixed: "fixed";
+          "random-once": "random-once";
+          "random-each": "random-each";
+        }>;
+        game: z.ZodNullable<z.ZodString>;
+        gameTitles: z.ZodRecord<z.ZodString, z.ZodString>;
+        lives: z.ZodNumber;
+        seeding: z.ZodEnum<{
+          rank: "rank";
+          random: "random";
+        }>;
+        start: z.ZodDiscriminatedUnion<[z.ZodObject<{
+          kind: z.ZodLiteral<"scheduled">;
+          at: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+          kind: z.ZodLiteral<"filled">;
+        }, z.core.$strip>], "kind">;
+        minPlayers: z.ZodNumber;
+        maxPlayers: z.ZodNumber;
+        readyMinutes: z.ZodNumber;
+        entrants: z.ZodNumber;
+        createdAt: z.ZodNumber;
+        startedAt: z.ZodNullable<z.ZodNumber>;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        champion: z.ZodNullable<z.ZodObject<{
+          id: z.ZodNumber;
+          username: z.ZodString;
+          avatar: z.ZodString;
+          guest: z.ZodBoolean;
+        }, z.core.$strip>>;
+        me: z.ZodObject<{
+          joined: z.ZodBoolean;
+          invited: z.ZodBoolean;
+          following: z.ZodBoolean;
+          leadMinutes: z.ZodNullable<z.ZodNumber>;
+          isCreator: z.ZodBoolean;
+          stillIn: z.ZodBoolean;
+          nextMatch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            opponent: z.ZodNullable<z.ZodObject<{
+              id: z.ZodNumber;
+              username: z.ZodString;
+              avatar: z.ZodString;
+              guest: z.ZodBoolean;
+            }, z.core.$strip>>;
+            game: z.ZodString;
+            gameTitle: z.ZodString;
+            deadlineAt: z.ZodNumber;
+            started: z.ZodBoolean;
+          }, z.core.$strip>>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly doc: {
+      readonly summary: "Lobbies to join now, invites, my tournaments and upcoming open ones (the home page card and modal)";
+      readonly tags: readonly ["tournaments"];
+    };
+  }, {
+    user: SessionUser | null;
+    clientId: string;
+  }, {}, import("@ayepi/core").EmptyObject>;
+};
+//#endregion
+//#region src/api/version.d.ts
+/**
+ * A semver range in the npm form: comparators (`>=2.0.0-0`, `<3.0.0`)
+ * separated by spaces are all required; `||` separates alternatives.
+ */
+export declare const VersionRange: z.ZodString;
+/** What `GET /version` answers. */
+export declare const HubVersion: z.ZodObject<{
+  server: z.ZodString;
+  contract: z.ZodString;
+  supported: z.ZodString;
+  deprecated: z.ZodString;
+}, z.core.$strip>;
+/** The hub's version and the client versions it supports. */
+export type HubVersion = z.infer<typeof HubVersion>;
+/** The version endpoints. */
 export declare const versionEndpoints: {
   getHubVersion: import("@ayepi/core").Endpoint<{
     readonly method: "GET";
@@ -5586,12 +7887,38 @@ export declare const versionEndpoints: {
   }, {}, import("@ayepi/core").EmptyObject>;
 };
 //#endregion
+//#region src/api/offline.d.ts
+/** The request header that carries a replayable call's operation key. */
+export declare const OFFLINE_OP_HEADER = "x-hub-op";
+/** An operation key: letters, digits and `_ . : -`, 1 to 100 characters. */
+export declare const OfflineOpKey: z.ZodString;
+/** How long the hub remembers an operation key's reply: 7 days. */
+export declare const OFFLINE_DEDUPE_TTL_MS: number;
+/** How an endpoint behaves offline: `replay` means it may be queued and sent later, deduplicated by its operation key. */
+export type OfflineMode = 'replay';
+/** The public endpoints that support offline replay, by name. */
+export declare const OFFLINE_REPLAY_ENDPOINTS: {
+  readonly writeSave: "replay";
+  readonly deleteSave: "replay";
+  readonly updateGameStat: "replay";
+  readonly setGameProfile: "replay";
+  readonly submitScore: "replay";
+  readonly completeDailyChallenge: "replay";
+  readonly grantInventoryItems: "replay";
+  readonly exchangeInventoryItems: "replay";
+  readonly setGameFavorite: "replay";
+};
+/** The name of an endpoint that supports offline replay. */
+export type OfflineReplayEndpoint = keyof typeof OFFLINE_REPLAY_ENDPOINTS;
+/** Whether endpoint `name` supports offline replay. */
+export declare function isOfflineReplayEndpoint(name: string): name is OfflineReplayEndpoint;
+//#endregion
 //#region src/api/index.d.ts
 /**
  * Every public endpoint, by name. Typed as an intersection of the areas so the
  * published .d.ts refers to each area instead of repeating every endpoint.
  */
-export type PublicEndpoints = typeof authEndpoints & typeof catalogEndpoints & typeof progressEndpoints & typeof leaderboardsEndpoints & typeof dailyEndpoints & typeof economyEndpoints & typeof analyticsEndpoints & typeof socialEndpoints & typeof messagesEndpoints & typeof notifyEndpoints & typeof reportsEndpoints & typeof mpEndpoints & typeof raceEndpoints & typeof versionEndpoints;
+export type PublicEndpoints = typeof authEndpoints & typeof catalogEndpoints & typeof progressEndpoints & typeof leaderboardsEndpoints & typeof dailyEndpoints & typeof economyEndpoints & typeof analyticsEndpoints & typeof socialEndpoints & typeof messagesEndpoints & typeof notifyEndpoints & typeof reportsEndpoints & typeof mpEndpoints & typeof raceEndpoints & typeof tournamentEndpoints & typeof playOnlineEndpoints & typeof versionEndpoints;
 /** Every public endpoint, by name. */
 export declare const publicEndpoints: PublicEndpoints;
 /**
@@ -5647,6 +7974,81 @@ export type EventData<E extends EventDef> = z.output<E['d']>;
 //#region src/realtime/events/multiplayer.d.ts
 /** The multiplayer events, by event name. */
 declare const multiplayerEvents: {
+  tournament: EventDef<import("zod").ZodObject<{
+    tournament: import("zod").ZodObject<{
+      id: import("zod").ZodNumber;
+      title: import("zod").ZodString;
+      creator: import("zod").ZodNullable<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        username: import("zod").ZodString;
+        avatar: import("zod").ZodString;
+        guest: import("zod").ZodBoolean;
+      }, import("zod/v4/core").$strip>>;
+      visibility: import("zod").ZodEnum<{
+        open: "open";
+        closed: "closed";
+      }>;
+      phase: import("zod").ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+        signup: "signup";
+        running: "running";
+      }>;
+      games: import("zod").ZodArray<import("zod").ZodString>;
+      pick: import("zod").ZodEnum<{
+        fixed: "fixed";
+        "random-once": "random-once";
+        "random-each": "random-each";
+      }>;
+      game: import("zod").ZodNullable<import("zod").ZodString>;
+      gameTitles: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+      lives: import("zod").ZodNumber;
+      seeding: import("zod").ZodEnum<{
+        rank: "rank";
+        random: "random";
+      }>;
+      start: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"scheduled">;
+        at: import("zod").ZodNumber;
+      }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        kind: import("zod").ZodLiteral<"filled">;
+      }, import("zod/v4/core").$strip>], "kind">;
+      minPlayers: import("zod").ZodNumber;
+      maxPlayers: import("zod").ZodNumber;
+      readyMinutes: import("zod").ZodNumber;
+      entrants: import("zod").ZodNumber;
+      createdAt: import("zod").ZodNumber;
+      startedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+      endedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+      champion: import("zod").ZodNullable<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        username: import("zod").ZodString;
+        avatar: import("zod").ZodString;
+        guest: import("zod").ZodBoolean;
+      }, import("zod/v4/core").$strip>>;
+      me: import("zod").ZodObject<{
+        joined: import("zod").ZodBoolean;
+        invited: import("zod").ZodBoolean;
+        following: import("zod").ZodBoolean;
+        leadMinutes: import("zod").ZodNullable<import("zod").ZodNumber>;
+        isCreator: import("zod").ZodBoolean;
+        stillIn: import("zod").ZodBoolean;
+        nextMatch: import("zod").ZodNullable<import("zod").ZodObject<{
+          id: import("zod").ZodString;
+          opponent: import("zod").ZodNullable<import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            username: import("zod").ZodString;
+            avatar: import("zod").ZodString;
+            guest: import("zod").ZodBoolean;
+          }, import("zod/v4/core").$strip>>;
+          game: import("zod").ZodString;
+          gameTitle: import("zod").ZodString;
+          deadlineAt: import("zod").ZodNumber;
+          started: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>>;
+      }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+  }, import("zod/v4/core").$strip>>;
   'race.start': EventDef<import("zod").ZodObject<{
     roomId: import("zod").ZodString;
     round: import("zod").ZodNumber;
@@ -5709,9 +8111,9 @@ declare const multiplayerEvents: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -5724,6 +8126,7 @@ declare const multiplayerEvents: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -5823,8 +8226,8 @@ declare const multiplayerEvents: {
   'room.closed': EventDef<import("zod").ZodObject<{
     reason: import("zod").ZodEnum<{
       ended: "ended";
-      removed: "removed";
       empty: "empty";
+      removed: "removed";
       host_left: "host_left";
       moved: "moved";
       other_tab: "other_tab";
@@ -5838,6 +8241,20 @@ declare const multiplayerEvents: {
       kicked: "kicked";
     }>;
   }, import("zod/v4/core").$strip>>;
+  'room.seat': EventDef<import("zod").ZodObject<{
+    userId: import("zod").ZodNumber;
+    status: import("zod").ZodEnum<{
+      away: "away";
+      back: "back";
+      gone: "gone";
+    }>;
+    graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+    reason: import("zod").ZodOptional<import("zod").ZodEnum<{
+      left: "left";
+      abandoned: "abandoned";
+      kicked: "kicked";
+    }>>;
+  }, import("zod/v4/core").$strip>>;
   invite: EventDef<import("zod").ZodObject<{
     id: import("zod").ZodString;
     from: import("zod").ZodObject<{
@@ -5995,6 +8412,7 @@ declare const socialEvents: {
       invite: "invite";
       suggestion: "suggestion";
       renamed: "renamed";
+      tournament: "tournament";
     }>;
     title: z.ZodString;
     body: z.ZodOptional<z.ZodString>;
@@ -6060,9 +8478,9 @@ declare const helloOps: {
       hostId: z.ZodNumber;
       public: z.ZodBoolean;
       phase: z.ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: z.ZodNumber;
       model: z.ZodEnum<{
@@ -6075,6 +8493,7 @@ declare const helloOps: {
         avatar: z.ZodString;
         ready: z.ZodBoolean;
         connected: z.ZodBoolean;
+        graceEndsAt: z.ZodOptional<z.ZodNumber>;
         data: z.ZodOptional<z.ZodJSONSchema>;
       }, z.core.$strip>>;
       spectators: z.ZodNumber;
@@ -6263,9 +8682,9 @@ declare const multiplayerOps: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -6278,6 +8697,7 @@ declare const multiplayerOps: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -6366,9 +8786,9 @@ declare const multiplayerOps: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -6381,6 +8801,7 @@ declare const multiplayerOps: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -6467,9 +8888,9 @@ declare const multiplayerOps: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -6482,6 +8903,7 @@ declare const multiplayerOps: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -6620,6 +9042,10 @@ declare const multiplayerOps: {
       host: "host";
       relay: "relay";
     }>>;
+    hostMigration: import("zod").ZodOptional<import("zod").ZodEnum<{
+      grace: "grace";
+      drop: "drop";
+    }>>;
     partyId: import("zod").ZodOptional<import("zod").ZodString>;
   }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     room: import("zod").ZodObject<{
@@ -6630,9 +9056,9 @@ declare const multiplayerOps: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -6645,6 +9071,7 @@ declare const multiplayerOps: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -6734,9 +9161,9 @@ declare const multiplayerOps: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -6749,6 +9176,7 @@ declare const multiplayerOps: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -6831,6 +9259,117 @@ declare const multiplayerOps: {
       to: import("zod").ZodOptional<import("zod").ZodNumber>;
     }, import("zod/v4/core").$strip>>;
   }, import("zod/v4/core").$strip>>;
+  'room.reclaim': OpDef<import("zod").ZodObject<{
+    game: import("zod").ZodString;
+  }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    held: import("zod").ZodNullable<import("zod").ZodObject<{
+      room: import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        code: import("zod").ZodString;
+        game: import("zod").ZodString;
+        mode: import("zod").ZodOptional<import("zod").ZodString>;
+        hostId: import("zod").ZodNumber;
+        public: import("zod").ZodBoolean;
+        phase: import("zod").ZodEnum<{
+          ended: "ended";
+          lobby: "lobby";
+          playing: "playing";
+        }>;
+        maxPlayers: import("zod").ZodNumber;
+        model: import("zod").ZodEnum<{
+          host: "host";
+          relay: "relay";
+        }>;
+        seats: import("zod").ZodArray<import("zod").ZodObject<{
+          userId: import("zod").ZodNumber;
+          name: import("zod").ZodString;
+          avatar: import("zod").ZodString;
+          ready: import("zod").ZodBoolean;
+          connected: import("zod").ZodBoolean;
+          graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+          data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
+        }, import("zod/v4/core").$strip>>;
+        spectators: import("zod").ZodNumber;
+        chatMode: import("zod").ZodEnum<{
+          on: "on";
+          quick: "quick";
+          off: "off";
+        }>;
+        race: import("zod").ZodOptional<import("zod").ZodObject<{
+          phase: import("zod").ZodEnum<{
+            waiting: "waiting";
+            countdown: "countdown";
+            racing: "racing";
+            done: "done";
+          }>;
+          round: import("zod").ZodNumber;
+          params: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>>;
+          minPlayers: import("zod").ZodNumber;
+          players: import("zod").ZodArray<import("zod").ZodObject<{
+            userId: import("zod").ZodNumber;
+            name: import("zod").ZodString;
+            avatar: import("zod").ZodString;
+            stats: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<number, number>>, import("zod").ZodBoolean, import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>]>>;
+            progress: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<number, number>>>;
+            state: import("zod").ZodEnum<{
+              racing: "racing";
+              finished: "finished";
+              lost: "lost";
+              forfeit: "forfeit";
+              disconnected: "disconnected";
+            }>;
+            ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+          }, import("zod/v4/core").$strip>>;
+          rematch: import("zod").ZodArray<import("zod").ZodNumber>;
+          seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+          startAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+          result: import("zod").ZodOptional<import("zod").ZodObject<{
+            game: import("zod").ZodString;
+            params: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodBoolean, import("zod").ZodString]>>;
+            outcome: import("zod").ZodEnum<{
+              finished: "finished";
+              lost: "lost";
+              forfeit: "forfeit";
+              disconnected: "disconnected";
+              timeout: "timeout";
+            }>;
+            startedAt: import("zod").ZodNumber;
+            endedAt: import("zod").ZodNumber;
+            durationMs: import("zod").ZodNumber;
+            id: import("zod").ZodNullable<import("zod").ZodNumber>;
+            room: import("zod").ZodString;
+            round: import("zod").ZodNumber;
+            seed: import("zod").ZodNumber;
+            winnerId: import("zod").ZodNullable<import("zod").ZodNumber>;
+            players: import("zod").ZodArray<import("zod").ZodObject<{
+              userId: import("zod").ZodNumber;
+              name: import("zod").ZodString;
+              avatar: import("zod").ZodString;
+              stats: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<number, number>>, import("zod").ZodBoolean, import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<string, string>>]>>;
+              progress: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodNumber, import("zod").ZodTransform<number, number>>>;
+              place: import("zod").ZodNumber;
+              result: import("zod").ZodEnum<{
+                lost: "lost";
+                forfeit: "forfeit";
+                disconnected: "disconnected";
+                timeout: "timeout";
+                won: "won";
+                beaten: "beaten";
+              }>;
+              ms: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+          }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+      }, import("zod/v4/core").$strip>;
+      state: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodJSONSchema>;
+      history: import("zod").ZodArray<import("zod").ZodObject<{
+        from: import("zod").ZodNumber;
+        data: import("zod").ZodJSONSchema;
+        seq: import("zod").ZodNumber;
+        to: import("zod").ZodOptional<import("zod").ZodNumber>;
+      }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+  }, import("zod/v4/core").$strip>>;
   'room.leave': OpDef<import("zod").ZodObject<{}, import("zod/v4/core").$strip>, import("zod").ZodObject<{}, import("zod/v4/core").$strip>>;
   'room.ready': OpDef<import("zod").ZodObject<{
     ready: import("zod").ZodBoolean;
@@ -6877,9 +9416,9 @@ declare const multiplayerOps: {
       hostId: import("zod").ZodNumber;
       public: import("zod").ZodBoolean;
       phase: import("zod").ZodEnum<{
+        ended: "ended";
         lobby: "lobby";
         playing: "playing";
-        ended: "ended";
       }>;
       maxPlayers: import("zod").ZodNumber;
       model: import("zod").ZodEnum<{
@@ -6892,6 +9431,7 @@ declare const multiplayerOps: {
         avatar: import("zod").ZodString;
         ready: import("zod").ZodBoolean;
         connected: import("zod").ZodBoolean;
+        graceEndsAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         data: import("zod").ZodOptional<import("zod").ZodJSONSchema>;
       }, import("zod/v4/core").$strip>>;
       spectators: import("zod").ZodNumber;
@@ -7216,6 +9756,7 @@ export declare const StaticGame: z.ZodObject<{
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>]>>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
   dailyChallenges: z.ZodOptional<z.ZodBoolean>;
   leaderboards: z.ZodOptional<z.ZodArray<z.ZodObject<{
     key: z.ZodString;
@@ -7304,6 +9845,7 @@ export declare const StaticGame: z.ZodObject<{
     join: z.ZodDefault<z.ZodBoolean>;
     spectate: z.ZodDefault<z.ZodBoolean>;
     quickMatch: z.ZodDefault<z.ZodBoolean>;
+    tournaments: z.ZodDefault<z.ZodBoolean>;
     modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
       key: z.ZodString;
       title: z.ZodOptional<z.ZodString>;
@@ -7319,6 +9861,7 @@ export declare const StaticGame: z.ZodObject<{
     join?: boolean | undefined;
     spectate?: boolean | undefined;
     quickMatch?: boolean | undefined;
+    tournaments?: boolean | undefined;
     modes?: {
       key: string;
       title?: string | undefined;
@@ -7348,6 +9891,7 @@ export declare const ProcessGame: z.ZodObject<{
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>]>>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
   dailyChallenges: z.ZodOptional<z.ZodBoolean>;
   leaderboards: z.ZodOptional<z.ZodArray<z.ZodObject<{
     key: z.ZodString;
@@ -7437,6 +9981,7 @@ export declare const ProcessGame: z.ZodObject<{
     join: z.ZodDefault<z.ZodBoolean>;
     spectate: z.ZodDefault<z.ZodBoolean>;
     quickMatch: z.ZodDefault<z.ZodBoolean>;
+    tournaments: z.ZodDefault<z.ZodBoolean>;
     modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
       key: z.ZodString;
       title: z.ZodOptional<z.ZodString>;
@@ -7452,6 +9997,7 @@ export declare const ProcessGame: z.ZodObject<{
     join?: boolean | undefined;
     spectate?: boolean | undefined;
     quickMatch?: boolean | undefined;
+    tournaments?: boolean | undefined;
     modes?: {
       key: string;
       title?: string | undefined;
@@ -7481,6 +10027,7 @@ export declare const GameManifest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>]>>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
   dailyChallenges: z.ZodOptional<z.ZodBoolean>;
   leaderboards: z.ZodOptional<z.ZodArray<z.ZodObject<{
     key: z.ZodString;
@@ -7569,6 +10116,7 @@ export declare const GameManifest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     join: z.ZodDefault<z.ZodBoolean>;
     spectate: z.ZodDefault<z.ZodBoolean>;
     quickMatch: z.ZodDefault<z.ZodBoolean>;
+    tournaments: z.ZodDefault<z.ZodBoolean>;
     modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
       key: z.ZodString;
       title: z.ZodOptional<z.ZodString>;
@@ -7584,6 +10132,7 @@ export declare const GameManifest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     join?: boolean | undefined;
     spectate?: boolean | undefined;
     quickMatch?: boolean | undefined;
+    tournaments?: boolean | undefined;
     modes?: {
       key: string;
       title?: string | undefined;
@@ -7611,6 +10160,7 @@ export declare const GameManifest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     x: z.ZodOptional<z.ZodNumber>;
     y: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strict>]>>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
   dailyChallenges: z.ZodOptional<z.ZodBoolean>;
   leaderboards: z.ZodOptional<z.ZodArray<z.ZodObject<{
     key: z.ZodString;
@@ -7700,6 +10250,7 @@ export declare const GameManifest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     join: z.ZodDefault<z.ZodBoolean>;
     spectate: z.ZodDefault<z.ZodBoolean>;
     quickMatch: z.ZodDefault<z.ZodBoolean>;
+    tournaments: z.ZodDefault<z.ZodBoolean>;
     modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
       key: z.ZodString;
       title: z.ZodOptional<z.ZodString>;
@@ -7715,6 +10266,7 @@ export declare const GameManifest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     join?: boolean | undefined;
     spectate?: boolean | undefined;
     quickMatch?: boolean | undefined;
+    tournaments?: boolean | undefined;
     modes?: {
       key: string;
       title?: string | undefined;
@@ -7754,6 +10306,7 @@ export declare const GamePackageJson: z.ZodObject<{
       x: z.ZodOptional<z.ZodNumber>;
       y: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
     dailyChallenges: z.ZodOptional<z.ZodBoolean>;
     leaderboards: z.ZodOptional<z.ZodArray<z.ZodObject<{
       key: z.ZodString;
@@ -7842,6 +10395,7 @@ export declare const GamePackageJson: z.ZodObject<{
       join: z.ZodDefault<z.ZodBoolean>;
       spectate: z.ZodDefault<z.ZodBoolean>;
       quickMatch: z.ZodDefault<z.ZodBoolean>;
+      tournaments: z.ZodDefault<z.ZodBoolean>;
       modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         title: z.ZodOptional<z.ZodString>;
@@ -7857,6 +10411,7 @@ export declare const GamePackageJson: z.ZodObject<{
       join?: boolean | undefined;
       spectate?: boolean | undefined;
       quickMatch?: boolean | undefined;
+      tournaments?: boolean | undefined;
       modes?: {
         key: string;
         title?: string | undefined;
@@ -7884,6 +10439,7 @@ export declare const GamePackageJson: z.ZodObject<{
       x: z.ZodOptional<z.ZodNumber>;
       y: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>]>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
     dailyChallenges: z.ZodOptional<z.ZodBoolean>;
     leaderboards: z.ZodOptional<z.ZodArray<z.ZodObject<{
       key: z.ZodString;
@@ -7973,6 +10529,7 @@ export declare const GamePackageJson: z.ZodObject<{
       join: z.ZodDefault<z.ZodBoolean>;
       spectate: z.ZodDefault<z.ZodBoolean>;
       quickMatch: z.ZodDefault<z.ZodBoolean>;
+      tournaments: z.ZodDefault<z.ZodBoolean>;
       modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         title: z.ZodOptional<z.ZodString>;
@@ -7988,6 +10545,7 @@ export declare const GamePackageJson: z.ZodObject<{
       join?: boolean | undefined;
       spectate?: boolean | undefined;
       quickMatch?: boolean | undefined;
+      tournaments?: boolean | undefined;
       modes?: {
         key: string;
         title?: string | undefined;
@@ -8043,6 +10601,66 @@ export declare const HubInject: z.ZodObject<{
 /** The injected `window.__HUB__` config. */
 export type HubInject = z.infer<typeof HubInject>;
 //#endregion
+//#region src/manifest/labels.d.ts
+/** The vocabulary, by group. */
+export declare const GAME_LABEL_GROUPS: {
+  /** What kind of game. */
+  readonly genre: readonly ["cards", "board", "puzzle", "arcade", "platformer", "real-time-strategy", "physics", "typing", "word", "sports", "racing"];
+  /** How it looks. */
+  readonly form: readonly ["2d", "3d"];
+  /** Where it plays: `phone` (touch controls), `controller` (gamepad support), `desktop` (keyboard or mouse only). */
+  readonly platform: readonly ["phone", "controller", "desktop"];
+  /** How many play. */
+  readonly play: readonly ["multiplayer", "single-player"];
+};
+/** A label group's key. */
+export type GameLabelGroup = keyof typeof GAME_LABEL_GROUPS;
+/** The groups in display order. */
+export declare const GAME_LABEL_GROUP_ORDER: readonly GameLabelGroup[];
+/** Every label, in display order (group by group). */
+export declare const GAME_LABELS: readonly ["cards", "board", "puzzle", "arcade", "platformer", "real-time-strategy", "physics", "typing", "word", "sports", "racing", "2d", "3d", "phone", "controller", "desktop", "multiplayer", "single-player"];
+/** One known label. */
+export declare const GameLabel: z.ZodEnum<{
+  racing: "racing";
+  typing: "typing";
+  multiplayer: "multiplayer";
+  board: "board";
+  cards: "cards";
+  puzzle: "puzzle";
+  arcade: "arcade";
+  platformer: "platformer";
+  "real-time-strategy": "real-time-strategy";
+  physics: "physics";
+  word: "word";
+  sports: "sports";
+  "2d": "2d";
+  "3d": "3d";
+  phone: "phone";
+  controller: "controller";
+  desktop: "desktop";
+  "single-player": "single-player";
+}>;
+/** One known label. */
+export type GameLabel = z.infer<typeof GameLabel>;
+/** Each label's display name. */
+export declare const GAME_LABEL_TITLES: Readonly<Record<GameLabel, string>>;
+/** Each group's display name. */
+export declare const GAME_LABEL_GROUP_TITLES: Readonly<Record<GameLabelGroup, string>>;
+/** Whether `text` is a known label. */
+export declare function isGameLabel(text: string): text is GameLabel;
+/** The group a label belongs to. */
+export declare function groupOfLabel(label: GameLabel): GameLabelGroup;
+/**
+ * `game.labels` as written: short strings. Unknown ones parse (they are a
+ * warning, see {@link splitGameLabels}).
+ */
+export declare const GameLabels: z.ZodArray<z.ZodString>;
+/** Known labels (trimmed, lower-cased, de-duplicated, in vocabulary order) and the unknown ones as written. */
+export declare function splitGameLabels(written: readonly string[]): {
+  readonly labels: GameLabel[];
+  readonly unknown: string[];
+};
+//#endregion
 //#region src/manifest/leaderboards.d.ts
 /** One declared leaderboard. */
 export declare const LeaderboardDecl: z.ZodObject<{
@@ -8107,6 +10725,7 @@ export declare const GameMultiplayer: z.ZodObject<{
   join: z.ZodDefault<z.ZodBoolean>;
   spectate: z.ZodDefault<z.ZodBoolean>;
   quickMatch: z.ZodDefault<z.ZodBoolean>;
+  tournaments: z.ZodDefault<z.ZodBoolean>;
   modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
     key: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
@@ -8129,6 +10748,7 @@ export declare const StaticGameMultiplayer: z.ZodObject<{
   join: z.ZodDefault<z.ZodBoolean>;
   spectate: z.ZodDefault<z.ZodBoolean>;
   quickMatch: z.ZodDefault<z.ZodBoolean>;
+  tournaments: z.ZodDefault<z.ZodBoolean>;
   modes: z.ZodDefault<z.ZodArray<z.ZodObject<{
     key: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
@@ -8335,6 +10955,30 @@ export declare const MANIFEST_LIMITS: {
   /** Largest `game.race.minMs`, in ms (10 minutes). */
   readonly raceMinMsMax: 600000;
 };
+/** What a tournament may be (batch-2026-10 R15). The server enforces each one. */
+export declare const TOURNAMENT_LIMITS: {
+  /** Longest title, in characters. */
+  readonly titleMax: 48;
+  /** Fewest players. */
+  readonly playersMin: 2;
+  /** Most players. */
+  readonly playersMax: 64;
+  /** Most games in the set a tournament picks from. */
+  readonly gamesMax: 8;
+  /** Lives per player: 1 single, 2 double, 3 triple elimination. */
+  readonly livesMax: 3;
+  /** The default and the longest window to join a ready match before forfeiting, in minutes. */
+  readonly readyMinutesDefault: 10;
+  readonly readyMinutesMax: 60;
+  /** The longest "remind me before it starts", in minutes (one day). */
+  readonly leadMinutesMax: 1440;
+  /** The default reminder for players who signed up for a scheduled tournament, in minutes. */
+  readonly leadMinutesDefault: 10;
+  /** The furthest ahead a tournament may be scheduled, in days. */
+  readonly scheduleDaysMax: 30;
+  /** Most friends invited in one call. */
+  readonly invitesMax: 50;
+};
 //#endregion
 //#region src/logic/daily.d.ts
 /**