moons-ta-client 1.3.3 → 1.4.0

package/dist/index.esm.js

@@ -8190,31 +8190,31 @@ var User_ClientTypes = /* @__PURE__ */ ((User_ClientTypes2) => {
   User_ClientTypes2[User_ClientTypes2["RESTConnection"] = 2] = "RESTConnection";
   return User_ClientTypes2;
 })(User_ClientTypes || {});
-var QualifierEvent_EventSettings = /* @__PURE__ */ ((QualifierEvent_EventSettings2) => {
-  QualifierEvent_EventSettings2[QualifierEvent_EventSettings2["None"] = 0] = "None";
-  QualifierEvent_EventSettings2[QualifierEvent_EventSettings2["HideScoresFromPlayers"] = 1] = "HideScoresFromPlayers";
-  QualifierEvent_EventSettings2[QualifierEvent_EventSettings2["DisableScoresaberSubmission"] = 2] = "DisableScoresaberSubmission";
-  QualifierEvent_EventSettings2[QualifierEvent_EventSettings2["EnableDiscordScoreFeed"] = 4] = "EnableDiscordScoreFeed";
-  QualifierEvent_EventSettings2[QualifierEvent_EventSettings2["EnableDiscordLeaderboard"] = 8] = "EnableDiscordLeaderboard";
-  return QualifierEvent_EventSettings2;
+var QualifierEvent_EventSettings = /* @__PURE__ */ ((QualifierEvent_EventSettings3) => {
+  QualifierEvent_EventSettings3[QualifierEvent_EventSettings3["None"] = 0] = "None";
+  QualifierEvent_EventSettings3[QualifierEvent_EventSettings3["HideScoresFromPlayers"] = 1] = "HideScoresFromPlayers";
+  QualifierEvent_EventSettings3[QualifierEvent_EventSettings3["DisableScoresaberSubmission"] = 2] = "DisableScoresaberSubmission";
+  QualifierEvent_EventSettings3[QualifierEvent_EventSettings3["EnableDiscordScoreFeed"] = 4] = "EnableDiscordScoreFeed";
+  QualifierEvent_EventSettings3[QualifierEvent_EventSettings3["EnableDiscordLeaderboard"] = 8] = "EnableDiscordLeaderboard";
+  return QualifierEvent_EventSettings3;
 })(QualifierEvent_EventSettings || {});
-var QualifierEvent_LeaderboardSort = /* @__PURE__ */ ((QualifierEvent_LeaderboardSort2) => {
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["ModifiedScore"] = 0] = "ModifiedScore";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["ModifiedScoreAscending"] = 1] = "ModifiedScoreAscending";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["ModifiedScoreTarget"] = 2] = "ModifiedScoreTarget";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["NotesMissed"] = 3] = "NotesMissed";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["NotesMissedAscending"] = 4] = "NotesMissedAscending";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["NotesMissedTarget"] = 5] = "NotesMissedTarget";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["BadCuts"] = 6] = "BadCuts";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["BadCutsAscending"] = 7] = "BadCutsAscending";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["BadCutsTarget"] = 8] = "BadCutsTarget";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["MaxCombo"] = 9] = "MaxCombo";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["MaxComboAscending"] = 10] = "MaxComboAscending";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["MaxComboTarget"] = 11] = "MaxComboTarget";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["GoodCuts"] = 12] = "GoodCuts";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["GoodCutsAscending"] = 13] = "GoodCutsAscending";
-  QualifierEvent_LeaderboardSort2[QualifierEvent_LeaderboardSort2["GoodCutsTarget"] = 14] = "GoodCutsTarget";
-  return QualifierEvent_LeaderboardSort2;
+var QualifierEvent_LeaderboardSort = /* @__PURE__ */ ((QualifierEvent_LeaderboardSort3) => {
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["ModifiedScore"] = 0] = "ModifiedScore";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["ModifiedScoreAscending"] = 1] = "ModifiedScoreAscending";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["ModifiedScoreTarget"] = 2] = "ModifiedScoreTarget";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["NotesMissed"] = 3] = "NotesMissed";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["NotesMissedAscending"] = 4] = "NotesMissedAscending";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["NotesMissedTarget"] = 5] = "NotesMissedTarget";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["BadCuts"] = 6] = "BadCuts";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["BadCutsAscending"] = 7] = "BadCutsAscending";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["BadCutsTarget"] = 8] = "BadCutsTarget";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["MaxCombo"] = 9] = "MaxCombo";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["MaxComboAscending"] = 10] = "MaxComboAscending";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["MaxComboTarget"] = 11] = "MaxComboTarget";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["GoodCuts"] = 12] = "GoodCuts";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["GoodCutsAscending"] = 13] = "GoodCutsAscending";
+  QualifierEvent_LeaderboardSort3[QualifierEvent_LeaderboardSort3["GoodCutsTarget"] = 14] = "GoodCutsTarget";
+  return QualifierEvent_LeaderboardSort3;
 })(QualifierEvent_LeaderboardSort || {});
 var Webhook_Trigger = /* @__PURE__ */ ((Webhook_Trigger2) => {
   Webhook_Trigger2[Webhook_Trigger2["None"] = 0] = "None";
@@ -8231,9 +8231,17 @@ var Webhook_Trigger = /* @__PURE__ */ ((Webhook_Trigger2) => {
   Webhook_Trigger2[Webhook_Trigger2["QualifierDeleted"] = 1024] = "QualifierDeleted";
   Webhook_Trigger2[Webhook_Trigger2["QualifierScoreSubmitted"] = 2048] = "QualifierScoreSubmitted";
   Webhook_Trigger2[Webhook_Trigger2["SongFinished"] = 4096] = "SongFinished";
-  Webhook_Trigger2[Webhook_Trigger2["All"] = 8191] = "All";
+  Webhook_Trigger2[Webhook_Trigger2["ReplaySubmitted"] = 8192] = "ReplaySubmitted";
+  Webhook_Trigger2[Webhook_Trigger2["All"] = 16383] = "All";
   return Webhook_Trigger2;
 })(Webhook_Trigger || {});
+var ReplayRetention = /* @__PURE__ */ ((ReplayRetention2) => {
+  ReplayRetention2[ReplayRetention2["ThirtyDays"] = 0] = "ThirtyDays";
+  ReplayRetention2[ReplayRetention2["NinetyDays"] = 1] = "NinetyDays";
+  ReplayRetention2[ReplayRetention2["OneYear"] = 2] = "OneYear";
+  ReplayRetention2[ReplayRetention2["ThreeYears"] = 3] = "ThreeYears";
+  return ReplayRetention2;
+})(ReplayRetention || {});
 var Characteristic$Type = class extends MessageType {
   constructor() {
     super("proto.models.Characteristic", [
@@ -9872,6 +9880,241 @@ var GlobalConfiguration$Type = class extends MessageType {
   }
 };
 var GlobalConfiguration = new GlobalConfiguration$Type();
+var ReplayRecording$Type = class extends MessageType {
+  constructor() {
+    super("proto.models.ReplayRecording", [
+      {
+        no: 1,
+        name: "guid",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "tournament_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "match_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "file_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "platform_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 6,
+        name: "player_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 7,
+        name: "map_hash",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 8,
+        name: "characteristic",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 9,
+        name: "difficulty",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 10,
+        name: "recorded_at",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 11,
+        name: "submitted_at",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 12,
+        name: "expires_at",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 13,
+        name: "size",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 14,
+        name: "download_url",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.guid = "";
+    message.tournamentId = "";
+    message.matchId = "";
+    message.fileName = "";
+    message.platformId = "";
+    message.playerName = "";
+    message.mapHash = "";
+    message.characteristic = "";
+    message.difficulty = 0;
+    message.recordedAt = 0n;
+    message.submittedAt = 0n;
+    message.expiresAt = 0n;
+    message.size = 0n;
+    message.downloadUrl = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string guid */
+        1:
+          message.guid = reader.string();
+          break;
+        case /* string tournament_id */
+        2:
+          message.tournamentId = reader.string();
+          break;
+        case /* string match_id */
+        3:
+          message.matchId = reader.string();
+          break;
+        case /* string file_name */
+        4:
+          message.fileName = reader.string();
+          break;
+        case /* string platform_id */
+        5:
+          message.platformId = reader.string();
+          break;
+        case /* string player_name */
+        6:
+          message.playerName = reader.string();
+          break;
+        case /* string map_hash */
+        7:
+          message.mapHash = reader.string();
+          break;
+        case /* string characteristic */
+        8:
+          message.characteristic = reader.string();
+          break;
+        case /* int32 difficulty */
+        9:
+          message.difficulty = reader.int32();
+          break;
+        case /* int64 recorded_at */
+        10:
+          message.recordedAt = reader.int64().toBigInt();
+          break;
+        case /* int64 submitted_at */
+        11:
+          message.submittedAt = reader.int64().toBigInt();
+          break;
+        case /* int64 expires_at */
+        12:
+          message.expiresAt = reader.int64().toBigInt();
+          break;
+        case /* int64 size */
+        13:
+          message.size = reader.int64().toBigInt();
+          break;
+        case /* string download_url */
+        14:
+          message.downloadUrl = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.guid !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.guid);
+    if (message.tournamentId !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.matchId !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.matchId);
+    if (message.fileName !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.fileName);
+    if (message.platformId !== "")
+      writer.tag(5, WireType.LengthDelimited).string(message.platformId);
+    if (message.playerName !== "")
+      writer.tag(6, WireType.LengthDelimited).string(message.playerName);
+    if (message.mapHash !== "")
+      writer.tag(7, WireType.LengthDelimited).string(message.mapHash);
+    if (message.characteristic !== "")
+      writer.tag(8, WireType.LengthDelimited).string(message.characteristic);
+    if (message.difficulty !== 0)
+      writer.tag(9, WireType.Varint).int32(message.difficulty);
+    if (message.recordedAt !== 0n)
+      writer.tag(10, WireType.Varint).int64(message.recordedAt);
+    if (message.submittedAt !== 0n)
+      writer.tag(11, WireType.Varint).int64(message.submittedAt);
+    if (message.expiresAt !== 0n)
+      writer.tag(12, WireType.Varint).int64(message.expiresAt);
+    if (message.size !== 0n)
+      writer.tag(13, WireType.Varint).int64(message.size);
+    if (message.downloadUrl !== "")
+      writer.tag(14, WireType.LengthDelimited).string(message.downloadUrl);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var ReplayRecording = new ReplayRecording$Type();
 var Tournament$Type = class extends MessageType {
   constructor() {
     super("proto.models.Tournament", [
@@ -10064,6 +10307,30 @@ var Tournament_TournamentSettings$Type = class extends MessageType {
         kind: "scalar",
         T: 9
         /*ScalarType.STRING*/
+      },
+      {
+        no: 18,
+        name: "enable_replay_recording",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      { no: 19, name: "replay_retention", kind: "enum", T: () => ["proto.models.ReplayRetention", ReplayRetention] },
+      {
+        no: 20,
+        name: "updated_at",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 21,
+        name: "auto_hide_at",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
       }
     ]);
   }
@@ -10086,6 +10353,10 @@ var Tournament_TournamentSettings$Type = class extends MessageType {
     message.allowMockClients = false;
     message.isBkTournament = false;
     message.beatKhanaTournamentGuid = "";
+    message.enableReplayRecording = false;
+    message.replayRetention = 0;
+    message.updatedAt = 0n;
+    message.autoHideAt = 0n;
     if (value !== void 0)
       reflectionMergePartial(this, message, value);
     return message;
@@ -10163,6 +10434,22 @@ var Tournament_TournamentSettings$Type = class extends MessageType {
         17:
           message.beatKhanaTournamentGuid = reader.string();
           break;
+        case /* bool enable_replay_recording */
+        18:
+          message.enableReplayRecording = reader.bool();
+          break;
+        case /* proto.models.ReplayRetention replay_retention */
+        19:
+          message.replayRetention = reader.int32();
+          break;
+        case /* int64 updated_at */
+        20:
+          message.updatedAt = reader.int64().toBigInt();
+          break;
+        case /* int64 auto_hide_at */
+        21:
+          message.autoHideAt = reader.int64().toBigInt();
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -10209,6 +10496,14 @@ var Tournament_TournamentSettings$Type = class extends MessageType {
       writer.tag(16, WireType.Varint).bool(message.isBkTournament);
     if (message.beatKhanaTournamentGuid !== "")
       writer.tag(17, WireType.LengthDelimited).string(message.beatKhanaTournamentGuid);
+    if (message.enableReplayRecording !== false)
+      writer.tag(18, WireType.Varint).bool(message.enableReplayRecording);
+    if (message.replayRetention !== 0)
+      writer.tag(19, WireType.Varint).int32(message.replayRetention);
+    if (message.updatedAt !== 0n)
+      writer.tag(20, WireType.Varint).int64(message.updatedAt);
+    if (message.autoHideAt !== 0n)
+      writer.tag(21, WireType.Varint).int64(message.autoHideAt);
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -11990,7 +12285,10 @@ var Response$Type = class extends MessageType {
       { no: 36, name: "get_global_configuration", kind: "message", oneof: "details", T: () => Response_GetGlobalConfiguration },
       { no: 37, name: "update_global_configuration", kind: "message", oneof: "details", T: () => Response_UpdateGlobalConfiguration },
       { no: 38, name: "create_bk_tournament", kind: "message", oneof: "details", T: () => Response_CreateBKTournament },
-      { no: 39, name: "set_bk_tournament_link", kind: "message", oneof: "details", T: () => Response_SetBKTournamentLink }
+      { no: 39, name: "set_bk_tournament_link", kind: "message", oneof: "details", T: () => Response_SetBKTournamentLink },
+      { no: 40, name: "submit_replay", kind: "message", oneof: "details", T: () => Response_SubmitReplay },
+      { no: 41, name: "get_replays", kind: "message", oneof: "details", T: () => Response_GetReplays },
+      { no: 42, name: "delete_replay", kind: "message", oneof: "details", T: () => Response_DeleteReplay }
     ]);
   }
   create(value) {
@@ -12274,6 +12572,27 @@ var Response$Type = class extends MessageType {
             setBkTournamentLink: Response_SetBKTournamentLink.internalBinaryRead(reader, reader.uint32(), options, message.details.setBkTournamentLink)
           };
           break;
+        case /* proto.packets.Response.SubmitReplay submit_replay */
+        40:
+          message.details = {
+            oneofKind: "submitReplay",
+            submitReplay: Response_SubmitReplay.internalBinaryRead(reader, reader.uint32(), options, message.details.submitReplay)
+          };
+          break;
+        case /* proto.packets.Response.GetReplays get_replays */
+        41:
+          message.details = {
+            oneofKind: "getReplays",
+            getReplays: Response_GetReplays.internalBinaryRead(reader, reader.uint32(), options, message.details.getReplays)
+          };
+          break;
+        case /* proto.packets.Response.DeleteReplay delete_replay */
+        42:
+          message.details = {
+            oneofKind: "deleteReplay",
+            deleteReplay: Response_DeleteReplay.internalBinaryRead(reader, reader.uint32(), options, message.details.deleteReplay)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -12364,6 +12683,12 @@ var Response$Type = class extends MessageType {
       Response_CreateBKTournament.internalBinaryWrite(message.details.createBkTournament, writer.tag(38, WireType.LengthDelimited).fork(), options).join();
     if (message.details.oneofKind === "setBkTournamentLink")
       Response_SetBKTournamentLink.internalBinaryWrite(message.details.setBkTournamentLink, writer.tag(39, WireType.LengthDelimited).fork(), options).join();
+    if (message.details.oneofKind === "submitReplay")
+      Response_SubmitReplay.internalBinaryWrite(message.details.submitReplay, writer.tag(40, WireType.LengthDelimited).fork(), options).join();
+    if (message.details.oneofKind === "getReplays")
+      Response_GetReplays.internalBinaryWrite(message.details.getReplays, writer.tag(41, WireType.LengthDelimited).fork(), options).join();
+    if (message.details.oneofKind === "deleteReplay")
+      Response_DeleteReplay.internalBinaryWrite(message.details.deleteReplay, writer.tag(42, WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -14649,22 +14974,22 @@ var Response_SetBKTournamentLink$Type = class extends MessageType {
   }
 };
 var Response_SetBKTournamentLink = new Response_SetBKTournamentLink$Type();
-var Response_CreateBKTournament$Type = class extends MessageType {
+var Response_SubmitReplay$Type = class extends MessageType {
   constructor() {
-    super("proto.packets.Response.CreateBKTournament", [
+    super("proto.packets.Response.SubmitReplay", [
       {
         no: 1,
-        name: "beat_khana_tournament_guid",
+        name: "message",
         kind: "scalar",
         T: 9
         /*ScalarType.STRING*/
       },
-      { no: 2, name: "tournament", kind: "message", T: () => Tournament }
+      { no: 2, name: "replay", kind: "message", T: () => ReplayRecording }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.beatKhanaTournamentGuid = "";
+    message.message = "";
     if (value !== void 0)
       reflectionMergePartial(this, message, value);
     return message;
@@ -14674,13 +14999,13 @@ var Response_CreateBKTournament$Type = class extends MessageType {
     while (reader.pos < end) {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
-        case /* string beat_khana_tournament_guid */
+        case /* string message */
         1:
-          message.beatKhanaTournamentGuid = reader.string();
+          message.message = reader.string();
           break;
-        case /* proto.models.Tournament tournament */
+        case /* proto.models.ReplayRecording replay */
         2:
-          message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+          message.replay = ReplayRecording.internalBinaryRead(reader, reader.uint32(), options, message.replay);
           break;
         default:
           let u = options.readUnknownField;
@@ -14694,32 +15019,250 @@ var Response_CreateBKTournament$Type = class extends MessageType {
     return message;
   }
   internalBinaryWrite(message, writer, options) {
-    if (message.beatKhanaTournamentGuid !== "")
-      writer.tag(1, WireType.LengthDelimited).string(message.beatKhanaTournamentGuid);
-    if (message.tournament)
-      Tournament.internalBinaryWrite(message.tournament, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.message !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.message);
+    if (message.replay)
+      ReplayRecording.internalBinaryWrite(message.replay, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
     return writer;
   }
 };
-var Response_CreateBKTournament = new Response_CreateBKTournament$Type();
-
-// src/models/requests.ts
-init_dirname();
-init_buffer2();
-init_process2();
-var Request$Type = class extends MessageType {
+var Response_SubmitReplay = new Response_SubmitReplay$Type();
+var Response_GetReplays$Type = class extends MessageType {
   constructor() {
-    super("proto.packets.Request", [
-      { no: 1, name: "update_user", kind: "message", oneof: "type", T: () => Request_UpdateUser },
-      { no: 2, name: "create_match", kind: "message", oneof: "type", T: () => Request_CreateMatch },
-      { no: 3, name: "add_user_to_match", kind: "message", oneof: "type", T: () => Request_AddUserToMatch },
-      { no: 4, name: "remove_user_from_match", kind: "message", oneof: "type", T: () => Request_RemoveUserFromMatch },
-      { no: 5, name: "set_match_leader", kind: "message", oneof: "type", T: () => Request_SetMatchLeader },
-      { no: 6, name: "set_match_map", kind: "message", oneof: "type", T: () => Request_SetMatchMap },
-      { no: 7, name: "delete_match", kind: "message", oneof: "type", T: () => Request_DeleteMatch },
+    super("proto.packets.Response.GetReplays", [
+      { no: 1, name: "replays", kind: "message", repeat: 2, T: () => ReplayRecording },
+      {
+        no: 2,
+        name: "total_count",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 3,
+        name: "page",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 4,
+        name: "page_size",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 5,
+        name: "storage_available",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.replays = [];
+    message.totalCount = 0;
+    message.page = 0;
+    message.pageSize = 0;
+    message.storageAvailable = false;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated proto.models.ReplayRecording replays */
+        1:
+          message.replays.push(ReplayRecording.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* int32 total_count */
+        2:
+          message.totalCount = reader.int32();
+          break;
+        case /* int32 page */
+        3:
+          message.page = reader.int32();
+          break;
+        case /* int32 page_size */
+        4:
+          message.pageSize = reader.int32();
+          break;
+        case /* bool storage_available */
+        5:
+          message.storageAvailable = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    for (let i = 0; i < message.replays.length; i++)
+      ReplayRecording.internalBinaryWrite(message.replays[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    if (message.totalCount !== 0)
+      writer.tag(2, WireType.Varint).int32(message.totalCount);
+    if (message.page !== 0)
+      writer.tag(3, WireType.Varint).int32(message.page);
+    if (message.pageSize !== 0)
+      writer.tag(4, WireType.Varint).int32(message.pageSize);
+    if (message.storageAvailable !== false)
+      writer.tag(5, WireType.Varint).bool(message.storageAvailable);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Response_GetReplays = new Response_GetReplays$Type();
+var Response_DeleteReplay$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Response.DeleteReplay", [
+      {
+        no: 1,
+        name: "replay_guid",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "message",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.replayGuid = "";
+    message.message = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string replay_guid */
+        1:
+          message.replayGuid = reader.string();
+          break;
+        case /* string message */
+        2:
+          message.message = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.replayGuid !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.replayGuid);
+    if (message.message !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.message);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Response_DeleteReplay = new Response_DeleteReplay$Type();
+var Response_CreateBKTournament$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Response.CreateBKTournament", [
+      {
+        no: 1,
+        name: "beat_khana_tournament_guid",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "tournament", kind: "message", T: () => Tournament }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.beatKhanaTournamentGuid = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string beat_khana_tournament_guid */
+        1:
+          message.beatKhanaTournamentGuid = reader.string();
+          break;
+        case /* proto.models.Tournament tournament */
+        2:
+          message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.beatKhanaTournamentGuid !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.beatKhanaTournamentGuid);
+    if (message.tournament)
+      Tournament.internalBinaryWrite(message.tournament, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Response_CreateBKTournament = new Response_CreateBKTournament$Type();
+
+// src/models/requests.ts
+init_dirname();
+init_buffer2();
+init_process2();
+var Request$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Request", [
+      { no: 1, name: "update_user", kind: "message", oneof: "type", T: () => Request_UpdateUser },
+      { no: 2, name: "create_match", kind: "message", oneof: "type", T: () => Request_CreateMatch },
+      { no: 3, name: "add_user_to_match", kind: "message", oneof: "type", T: () => Request_AddUserToMatch },
+      { no: 4, name: "remove_user_from_match", kind: "message", oneof: "type", T: () => Request_RemoveUserFromMatch },
+      { no: 5, name: "set_match_leader", kind: "message", oneof: "type", T: () => Request_SetMatchLeader },
+      { no: 6, name: "set_match_map", kind: "message", oneof: "type", T: () => Request_SetMatchMap },
+      { no: 7, name: "delete_match", kind: "message", oneof: "type", T: () => Request_DeleteMatch },
       { no: 8, name: "create_qualifier_event", kind: "message", oneof: "type", T: () => Request_CreateQualifierEvent },
       { no: 9, name: "set_qualifier_name", kind: "message", oneof: "type", T: () => Request_SetQualifierName },
       { no: 10, name: "set_qualifier_info_channel", kind: "message", oneof: "type", T: () => Request_SetQualifierInfoChannel },
@@ -14785,7 +15328,12 @@ var Request$Type = class extends MessageType {
       { no: 72, name: "delete_webhook", kind: "message", oneof: "type", T: () => Request_DeleteWebhook },
       { no: 73, name: "get_global_configuration", kind: "message", oneof: "type", T: () => Request_GetGlobalConfiguration },
       { no: 74, name: "update_global_configuration", kind: "message", oneof: "type", T: () => Request_UpdateGlobalConfiguration },
-      { no: 75, name: "set_bk_tournament_link", kind: "message", oneof: "type", T: () => Request_SetBKTournamentLink }
+      { no: 75, name: "set_bk_tournament_link", kind: "message", oneof: "type", T: () => Request_SetBKTournamentLink },
+      { no: 76, name: "set_tournament_enable_replay_recording", kind: "message", oneof: "type", T: () => Request_SetTournamentEnableReplayRecording },
+      { no: 77, name: "set_tournament_replay_retention", kind: "message", oneof: "type", T: () => Request_SetTournamentReplayRetention },
+      { no: 78, name: "submit_replay", kind: "message", oneof: "type", T: () => Request_SubmitReplay },
+      { no: 79, name: "get_replays", kind: "message", oneof: "type", T: () => Request_GetReplays },
+      { no: 80, name: "delete_replay", kind: "message", oneof: "type", T: () => Request_DeleteReplay }
     ]);
   }
   create(value) {
@@ -15311,6 +15859,41 @@ var Request$Type = class extends MessageType {
             setBkTournamentLink: Request_SetBKTournamentLink.internalBinaryRead(reader, reader.uint32(), options, message.type.setBkTournamentLink)
           };
           break;
+        case /* proto.packets.Request.SetTournamentEnableReplayRecording set_tournament_enable_replay_recording */
+        76:
+          message.type = {
+            oneofKind: "setTournamentEnableReplayRecording",
+            setTournamentEnableReplayRecording: Request_SetTournamentEnableReplayRecording.internalBinaryRead(reader, reader.uint32(), options, message.type.setTournamentEnableReplayRecording)
+          };
+          break;
+        case /* proto.packets.Request.SetTournamentReplayRetention set_tournament_replay_retention */
+        77:
+          message.type = {
+            oneofKind: "setTournamentReplayRetention",
+            setTournamentReplayRetention: Request_SetTournamentReplayRetention.internalBinaryRead(reader, reader.uint32(), options, message.type.setTournamentReplayRetention)
+          };
+          break;
+        case /* proto.packets.Request.SubmitReplay submit_replay */
+        78:
+          message.type = {
+            oneofKind: "submitReplay",
+            submitReplay: Request_SubmitReplay.internalBinaryRead(reader, reader.uint32(), options, message.type.submitReplay)
+          };
+          break;
+        case /* proto.packets.Request.GetReplays get_replays */
+        79:
+          message.type = {
+            oneofKind: "getReplays",
+            getReplays: Request_GetReplays.internalBinaryRead(reader, reader.uint32(), options, message.type.getReplays)
+          };
+          break;
+        case /* proto.packets.Request.DeleteReplay delete_replay */
+        80:
+          message.type = {
+            oneofKind: "deleteReplay",
+            deleteReplay: Request_DeleteReplay.internalBinaryRead(reader, reader.uint32(), options, message.type.deleteReplay)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -15469,6 +16052,16 @@ var Request$Type = class extends MessageType {
       Request_UpdateGlobalConfiguration.internalBinaryWrite(message.type.updateGlobalConfiguration, writer.tag(74, WireType.LengthDelimited).fork(), options).join();
     if (message.type.oneofKind === "setBkTournamentLink")
       Request_SetBKTournamentLink.internalBinaryWrite(message.type.setBkTournamentLink, writer.tag(75, WireType.LengthDelimited).fork(), options).join();
+    if (message.type.oneofKind === "setTournamentEnableReplayRecording")
+      Request_SetTournamentEnableReplayRecording.internalBinaryWrite(message.type.setTournamentEnableReplayRecording, writer.tag(76, WireType.LengthDelimited).fork(), options).join();
+    if (message.type.oneofKind === "setTournamentReplayRetention")
+      Request_SetTournamentReplayRetention.internalBinaryWrite(message.type.setTournamentReplayRetention, writer.tag(77, WireType.LengthDelimited).fork(), options).join();
+    if (message.type.oneofKind === "submitReplay")
+      Request_SubmitReplay.internalBinaryWrite(message.type.submitReplay, writer.tag(78, WireType.LengthDelimited).fork(), options).join();
+    if (message.type.oneofKind === "getReplays")
+      Request_GetReplays.internalBinaryWrite(message.type.getReplays, writer.tag(79, WireType.LengthDelimited).fork(), options).join();
+    if (message.type.oneofKind === "deleteReplay")
+      Request_DeleteReplay.internalBinaryWrite(message.type.deleteReplay, writer.tag(80, WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -20558,38 +21151,29 @@ var Request_SetBKTournamentLink$Type = class extends MessageType {
   }
 };
 var Request_SetBKTournamentLink = new Request_SetBKTournamentLink$Type();
-var Request_CreateBKTournament$Type = class extends MessageType {
+var Request_SetTournamentEnableReplayRecording$Type = class extends MessageType {
   constructor() {
-    super("proto.packets.Request.CreateBKTournament", [
+    super("proto.packets.Request.SetTournamentEnableReplayRecording", [
       {
         no: 1,
-        name: "beat_khana_tournament_guid",
+        name: "tournament_id",
         kind: "scalar",
         T: 9
         /*ScalarType.STRING*/
       },
-      { no: 2, name: "tournament", kind: "message", T: () => Tournament },
-      { no: 3, name: "organizer", kind: "message", T: () => Request_CreateBKTournament_BeatKhanaUser },
       {
-        no: 4,
-        name: "organizer_permissions",
+        no: 2,
+        name: "enable_replay_recording",
         kind: "scalar",
-        repeat: 2,
-        T: 9
-        /*ScalarType.STRING*/
-      },
-      { no: 5, name: "roles", kind: "message", repeat: 2, T: () => Role },
-      { no: 6, name: "authorized_users", kind: "message", repeat: 2, T: () => Request_CreateBKTournament_AuthorizedUser },
-      { no: 7, name: "webhooks", kind: "message", repeat: 2, T: () => Request_CreateBKTournament_WebhookRegistration }
+        T: 8
+        /*ScalarType.BOOL*/
+      }
     ]);
   }
   create(value) {
     const message = globalThis.Object.create(this.messagePrototype);
-    message.beatKhanaTournamentGuid = "";
-    message.organizerPermissions = [];
-    message.roles = [];
-    message.authorizedUsers = [];
-    message.webhooks = [];
+    message.tournamentId = "";
+    message.enableReplayRecording = false;
     if (value !== void 0)
       reflectionMergePartial(this, message, value);
     return message;
@@ -20599,33 +21183,450 @@ var Request_CreateBKTournament$Type = class extends MessageType {
     while (reader.pos < end) {
       let [fieldNo, wireType] = reader.tag();
       switch (fieldNo) {
-        case /* string beat_khana_tournament_guid */
+        case /* string tournament_id */
         1:
-          message.beatKhanaTournamentGuid = reader.string();
+          message.tournamentId = reader.string();
           break;
-        case /* proto.models.Tournament tournament */
+        case /* bool enable_replay_recording */
         2:
-          message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
-          break;
-        case /* proto.packets.Request.CreateBKTournament.BeatKhanaUser organizer */
-        3:
-          message.organizer = Request_CreateBKTournament_BeatKhanaUser.internalBinaryRead(reader, reader.uint32(), options, message.organizer);
-          break;
-        case /* repeated string organizer_permissions */
-        4:
-          message.organizerPermissions.push(reader.string());
-          break;
-        case /* repeated proto.models.Role roles */
-        5:
-          message.roles.push(Role.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        case /* repeated proto.packets.Request.CreateBKTournament.AuthorizedUser authorized_users */
-        6:
-          message.authorizedUsers.push(Request_CreateBKTournament_AuthorizedUser.internalBinaryRead(reader, reader.uint32(), options));
-          break;
-        case /* repeated proto.packets.Request.CreateBKTournament.WebhookRegistration webhooks */
-        7:
-          message.webhooks.push(Request_CreateBKTournament_WebhookRegistration.internalBinaryRead(reader, reader.uint32(), options));
+          message.enableReplayRecording = reader.bool();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tournamentId !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.enableReplayRecording !== false)
+      writer.tag(2, WireType.Varint).bool(message.enableReplayRecording);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Request_SetTournamentEnableReplayRecording = new Request_SetTournamentEnableReplayRecording$Type();
+var Request_SetTournamentReplayRetention$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Request.SetTournamentReplayRetention", [
+      {
+        no: 1,
+        name: "tournament_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "replay_retention", kind: "enum", T: () => ["proto.models.ReplayRetention", ReplayRetention] }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tournamentId = "";
+    message.replayRetention = 0;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string tournament_id */
+        1:
+          message.tournamentId = reader.string();
+          break;
+        case /* proto.models.ReplayRetention replay_retention */
+        2:
+          message.replayRetention = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tournamentId !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.replayRetention !== 0)
+      writer.tag(2, WireType.Varint).int32(message.replayRetention);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Request_SetTournamentReplayRetention = new Request_SetTournamentReplayRetention$Type();
+var Request_SubmitReplay$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Request.SubmitReplay", [
+      {
+        no: 1,
+        name: "tournament_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "match_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 3,
+        name: "upload_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 4,
+        name: "file_name",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 5,
+        name: "chunk_index",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 6,
+        name: "chunk_count",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 7,
+        name: "total_size",
+        kind: "scalar",
+        T: 3,
+        L: 0
+        /*LongType.BIGINT*/
+      },
+      {
+        no: 8,
+        name: "data",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tournamentId = "";
+    message.matchId = "";
+    message.uploadId = "";
+    message.fileName = "";
+    message.chunkIndex = 0;
+    message.chunkCount = 0;
+    message.totalSize = 0n;
+    message.data = new Uint8Array(0);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string tournament_id */
+        1:
+          message.tournamentId = reader.string();
+          break;
+        case /* string match_id */
+        2:
+          message.matchId = reader.string();
+          break;
+        case /* string upload_id */
+        3:
+          message.uploadId = reader.string();
+          break;
+        case /* string file_name */
+        4:
+          message.fileName = reader.string();
+          break;
+        case /* int32 chunk_index */
+        5:
+          message.chunkIndex = reader.int32();
+          break;
+        case /* int32 chunk_count */
+        6:
+          message.chunkCount = reader.int32();
+          break;
+        case /* int64 total_size */
+        7:
+          message.totalSize = reader.int64().toBigInt();
+          break;
+        case /* bytes data */
+        8:
+          message.data = reader.bytes();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tournamentId !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.matchId !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.matchId);
+    if (message.uploadId !== "")
+      writer.tag(3, WireType.LengthDelimited).string(message.uploadId);
+    if (message.fileName !== "")
+      writer.tag(4, WireType.LengthDelimited).string(message.fileName);
+    if (message.chunkIndex !== 0)
+      writer.tag(5, WireType.Varint).int32(message.chunkIndex);
+    if (message.chunkCount !== 0)
+      writer.tag(6, WireType.Varint).int32(message.chunkCount);
+    if (message.totalSize !== 0n)
+      writer.tag(7, WireType.Varint).int64(message.totalSize);
+    if (message.data.length)
+      writer.tag(8, WireType.LengthDelimited).bytes(message.data);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Request_SubmitReplay = new Request_SubmitReplay$Type();
+var Request_GetReplays$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Request.GetReplays", [
+      {
+        no: 1,
+        name: "tournament_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "page",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      },
+      {
+        no: 3,
+        name: "page_size",
+        kind: "scalar",
+        T: 5
+        /*ScalarType.INT32*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tournamentId = "";
+    message.page = 0;
+    message.pageSize = 0;
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string tournament_id */
+        1:
+          message.tournamentId = reader.string();
+          break;
+        case /* int32 page */
+        2:
+          message.page = reader.int32();
+          break;
+        case /* int32 page_size */
+        3:
+          message.pageSize = reader.int32();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tournamentId !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.page !== 0)
+      writer.tag(2, WireType.Varint).int32(message.page);
+    if (message.pageSize !== 0)
+      writer.tag(3, WireType.Varint).int32(message.pageSize);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Request_GetReplays = new Request_GetReplays$Type();
+var Request_DeleteReplay$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Request.DeleteReplay", [
+      {
+        no: 1,
+        name: "tournament_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      {
+        no: 2,
+        name: "replay_guid",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tournamentId = "";
+    message.replayGuid = "";
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string tournament_id */
+        1:
+          message.tournamentId = reader.string();
+          break;
+        case /* string replay_guid */
+        2:
+          message.replayGuid = reader.string();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tournamentId !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.replayGuid !== "")
+      writer.tag(2, WireType.LengthDelimited).string(message.replayGuid);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Request_DeleteReplay = new Request_DeleteReplay$Type();
+var Request_CreateBKTournament$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Request.CreateBKTournament", [
+      {
+        no: 1,
+        name: "beat_khana_tournament_guid",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "tournament", kind: "message", T: () => Tournament },
+      { no: 3, name: "organizer", kind: "message", T: () => Request_CreateBKTournament_BeatKhanaUser },
+      {
+        no: 4,
+        name: "organizer_permissions",
+        kind: "scalar",
+        repeat: 2,
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 5, name: "roles", kind: "message", repeat: 2, T: () => Role },
+      { no: 6, name: "authorized_users", kind: "message", repeat: 2, T: () => Request_CreateBKTournament_AuthorizedUser },
+      { no: 7, name: "webhooks", kind: "message", repeat: 2, T: () => Request_CreateBKTournament_WebhookRegistration }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.beatKhanaTournamentGuid = "";
+    message.organizerPermissions = [];
+    message.roles = [];
+    message.authorizedUsers = [];
+    message.webhooks = [];
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string beat_khana_tournament_guid */
+        1:
+          message.beatKhanaTournamentGuid = reader.string();
+          break;
+        case /* proto.models.Tournament tournament */
+        2:
+          message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+          break;
+        case /* proto.packets.Request.CreateBKTournament.BeatKhanaUser organizer */
+        3:
+          message.organizer = Request_CreateBKTournament_BeatKhanaUser.internalBinaryRead(reader, reader.uint32(), options, message.organizer);
+          break;
+        case /* repeated string organizer_permissions */
+        4:
+          message.organizerPermissions.push(reader.string());
+          break;
+        case /* repeated proto.models.Role roles */
+        5:
+          message.roles.push(Role.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* repeated proto.packets.Request.CreateBKTournament.AuthorizedUser authorized_users */
+        6:
+          message.authorizedUsers.push(Request_CreateBKTournament_AuthorizedUser.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* repeated proto.packets.Request.CreateBKTournament.WebhookRegistration webhooks */
+        7:
+          message.webhooks.push(Request_CreateBKTournament_WebhookRegistration.internalBinaryRead(reader, reader.uint32(), options));
           break;
         default:
           let u = options.readUnknownField;
@@ -20888,7 +21889,8 @@ var Push$Type = class extends MessageType {
     super("proto.packets.Push", [
       { no: 1, name: "realtime_score", kind: "message", oneof: "data", T: () => RealtimeScore },
       { no: 2, name: "song_finished", kind: "message", oneof: "data", T: () => Push_SongFinished },
-      { no: 3, name: "qualifier_score_submtited", kind: "message", oneof: "data", T: () => Push_QualifierScoreSubmitted }
+      { no: 3, name: "qualifier_score_submtited", kind: "message", oneof: "data", T: () => Push_QualifierScoreSubmitted },
+      { no: 4, name: "replay_submitted", kind: "message", oneof: "data", T: () => Push_ReplaySubmitted }
     ]);
   }
   create(value) {
@@ -20924,6 +21926,13 @@ var Push$Type = class extends MessageType {
             qualifierScoreSubmtited: Push_QualifierScoreSubmitted.internalBinaryRead(reader, reader.uint32(), options, message.data.qualifierScoreSubmtited)
           };
           break;
+        case /* proto.packets.Push.ReplaySubmitted replay_submitted */
+        4:
+          message.data = {
+            oneofKind: "replaySubmitted",
+            replaySubmitted: Push_ReplaySubmitted.internalBinaryRead(reader, reader.uint32(), options, message.data.replaySubmitted)
+          };
+          break;
         default:
           let u = options.readUnknownField;
           if (u === "throw")
@@ -20942,6 +21951,8 @@ var Push$Type = class extends MessageType {
       Push_SongFinished.internalBinaryWrite(message.data.songFinished, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
     if (message.data.oneofKind === "qualifierScoreSubmtited")
       Push_QualifierScoreSubmitted.internalBinaryWrite(message.data.qualifierScoreSubmtited, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    if (message.data.oneofKind === "replaySubmitted")
+      Push_ReplaySubmitted.internalBinaryWrite(message.data.replaySubmitted, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
     let u = options.writeUnknownFields;
     if (u !== false)
       (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -21202,6 +22213,90 @@ var Push_QualifierScoreSubmitted$Type = class extends MessageType {
   }
 };
 var Push_QualifierScoreSubmitted = new Push_QualifierScoreSubmitted$Type();
+var Push_ReplaySubmitted$Type = class extends MessageType {
+  constructor() {
+    super("proto.packets.Push.ReplaySubmitted", [
+      {
+        no: 1,
+        name: "tournament_id",
+        kind: "scalar",
+        T: 9
+        /*ScalarType.STRING*/
+      },
+      { no: 2, name: "replay", kind: "message", T: () => ReplayRecording },
+      {
+        no: 3,
+        name: "stored",
+        kind: "scalar",
+        T: 8
+        /*ScalarType.BOOL*/
+      },
+      {
+        no: 4,
+        name: "data",
+        kind: "scalar",
+        T: 12
+        /*ScalarType.BYTES*/
+      }
+    ]);
+  }
+  create(value) {
+    const message = globalThis.Object.create(this.messagePrototype);
+    message.tournamentId = "";
+    message.stored = false;
+    message.data = new Uint8Array(0);
+    if (value !== void 0)
+      reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    let message = target ?? this.create(), end = reader.pos + length;
+    while (reader.pos < end) {
+      let [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string tournament_id */
+        1:
+          message.tournamentId = reader.string();
+          break;
+        case /* proto.models.ReplayRecording replay */
+        2:
+          message.replay = ReplayRecording.internalBinaryRead(reader, reader.uint32(), options, message.replay);
+          break;
+        case /* bool stored */
+        3:
+          message.stored = reader.bool();
+          break;
+        case /* bytes data */
+        4:
+          message.data = reader.bytes();
+          break;
+        default:
+          let u = options.readUnknownField;
+          if (u === "throw")
+            throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          let d = reader.skip(wireType);
+          if (u !== false)
+            (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    if (message.tournamentId !== "")
+      writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+    if (message.replay)
+      ReplayRecording.internalBinaryWrite(message.replay, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    if (message.stored !== false)
+      writer.tag(3, WireType.Varint).bool(message.stored);
+    if (message.data.length)
+      writer.tag(4, WireType.LengthDelimited).bytes(message.data);
+    let u = options.writeUnknownFields;
+    if (u !== false)
+      (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+};
+var Push_ReplaySubmitted = new Push_ReplaySubmitted$Type();
 
 // src/models/commands.ts
 init_dirname();
@@ -22193,8 +23288,8 @@ init_process2();
 var masterAddress = "server.tournamentassistant.net";
 var masterPort = "8676";
 var masterApiPort = "8678";
-var version = "1.3.3";
-var versionCode = 1330;
+var version = "1.4.0";
+var versionCode = 1400;
 
 // src/tournament-assistant-client.ts
 var import_ws2 = __toESM(require_ws(), 1);
@@ -22891,6 +23986,8 @@ var TAClient = class extends CustomEventEmitter {
         this.emit("realtimeScore", push.data.realtimeScore);
       } else if (push.data.oneofKind === "qualifierScoreSubmtited") {
         this.emit("qualifierScoreSubmitted", push.data.qualifierScoreSubmtited);
+      } else if (push.data.oneofKind === "replaySubmitted") {
+        this.emit("replaySubmitted", push.data.replaySubmitted);
       }
     }
   };
@@ -23372,6 +24469,12 @@ var TAClient = class extends CustomEventEmitter {
               enableTeams,
               enablePools,
               enableReplayStreaming,
+              enableReplayRecording: false,
+              replayRetention: 0 /* ThirtyDays */,
+              updatedAt: 0n,
+              // set by the server
+              autoHideAt: 0n,
+              // set by the server
               allowMockClients,
               isBkTournament: false,
               beatKhanaTournamentGuid: "",
@@ -23475,6 +24578,65 @@ var TAClient = class extends CustomEventEmitter {
     }
     return response[0].response;
   };
+  setTournamentEnableReplayRecording = async (tournamentId, enableReplayRecording) => {
+    const response = await this.sendRequest({
+      type: {
+        oneofKind: "setTournamentEnableReplayRecording",
+        setTournamentEnableReplayRecording: {
+          tournamentId,
+          enableReplayRecording
+        }
+      }
+    });
+    if (response.length <= 0) {
+      throw new Error("Server timed out");
+    }
+    return response[0].response;
+  };
+  setTournamentReplayRetention = async (tournamentId, replayRetention) => {
+    const response = await this.sendRequest({
+      type: {
+        oneofKind: "setTournamentReplayRetention",
+        setTournamentReplayRetention: {
+          tournamentId,
+          replayRetention
+        }
+      }
+    });
+    if (response.length <= 0) {
+      throw new Error("Server timed out");
+    }
+    return response[0].response;
+  };
+  // Pages start at 0, the newest replays come first
+  getReplays = async (tournamentId, page, pageSize) => {
+    const response = await this.sendRequest({
+      type: { oneofKind: "getReplays", getReplays: { tournamentId, page, pageSize } }
+    });
+    if (response.length <= 0)
+      throw new Error("Server timed out");
+    return response[0].response;
+  };
+  deleteReplay = async (tournamentId, replayGuid) => {
+    const response = await this.sendRequest({
+      type: { oneofKind: "deleteReplay", deleteReplay: { tournamentId, replayGuid } }
+    });
+    if (response.length <= 0)
+      throw new Error("Server timed out");
+    return response[0].response;
+  };
+  // Replays can be larger than a packet, so they are downloaded over the REST API with the same token
+  downloadReplay = async (downloadUrl) => {
+    const response = await fetch(downloadUrl, {
+      headers: {
+        Authorization: `Bearer ${this.token}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Download failed: " + await response.text());
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  };
   setTournamentAllowMockClients = async (tournamentId, allowMockClients) => {
     const response = await this.sendRequest({
       type: {
@@ -23933,6 +25095,7 @@ export {
   PlayerSpecificSettings_PlayerOptions,
   Push,
   Push_QualifierScoreSubmitted,
+  Push_ReplaySubmitted,
   Push_SongFinished,
   Push_SongFinished_CompletionType,
   QualifierEvent,
@@ -23957,6 +25120,8 @@ export {
   ReplayPose,
   ReplayPoseFrame,
   ReplayQuaternion,
+  ReplayRecording,
+  ReplayRetention,
   ReplayScoreEvent,
   ReplayScoreSummary,
   ReplayStreamEnd,
@@ -23983,6 +25148,7 @@ export {
   Request_CreateWebhook,
   Request_DeleteMatch,
   Request_DeleteQualifierEvent,
+  Request_DeleteReplay,
   Request_DeleteTournament,
   Request_DeleteWebhook,
   Request_GenerateBotToken,
@@ -23990,6 +25156,7 @@ export {
   Request_GetBotTokensForUser,
   Request_GetDiscordInfo,
   Request_GetGlobalConfiguration,
+  Request_GetReplays,
   Request_GetWebhooks,
   Request_Join,
   Request_LeaveTournament,
@@ -24020,12 +25187,14 @@ export {
   Request_SetTournamentAllowUnauthorizedView,
   Request_SetTournamentBannedMods,
   Request_SetTournamentEnablePools,
+  Request_SetTournamentEnableReplayRecording,
   Request_SetTournamentEnableReplayStreaming,
   Request_SetTournamentEnableTeams,
   Request_SetTournamentImage,
   Request_SetTournamentName,
   Request_SetTournamentPoolImage,
   Request_SetTournamentPoolName,
+  Request_SetTournamentReplayRetention,
   Request_SetTournamentRoleName,
   Request_SetTournamentRolePermissions,
   Request_SetTournamentScoreUpdateFrequency,
@@ -24036,6 +25205,7 @@ export {
   Request_ShowPrompt,
   Request_ShowPrompt_PromptOption,
   Request_SubmitQualifierScore,
+  Request_SubmitReplay,
   Request_UpdateAuthorizedUserRoles,
   Request_UpdateGlobalConfiguration,
   Request_UpdateQualifierMap,
@@ -24054,6 +25224,7 @@ export {
   Response_CreateWebhook,
   Response_DeleteMatch,
   Response_DeleteQualifierEvent,
+  Response_DeleteReplay,
   Response_DeleteTournament,
   Response_DeleteWebhook,
   Response_GenerateBotToken,
@@ -24063,6 +25234,7 @@ export {
   Response_GetBotTokensForUser_BotUser,
   Response_GetDiscordInfo,
   Response_GetGlobalConfiguration,
+  Response_GetReplays,
   Response_GetWebhooks,
   Response_Join,
   Response_Join_JoinFailReason,
@@ -24078,6 +25250,7 @@ export {
   Response_RevokeBotToken,
   Response_SetBKTournamentLink,
   Response_ShowPrompt,
+  Response_SubmitReplay,
   Response_UpdateAuthorizedUser,
   Response_UpdateGlobalConfiguration,
   Response_UpdateMatch,