moons-ta-client 1.0.1

package/src/models/requests.ts

@@ -0,0 +1,4773 @@
+// @generated by protobuf-ts 2.8.2
+// @generated from protobuf file "requests.proto" (package "proto.packets", syntax proto3)
+// tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { ModalOption } from './models.js';
+import { GameplayParameters } from './models.js';
+import { LeaderboardEntry } from './models.js';
+import { CoreServer } from './models.js';
+import { Tournament_TournamentSettings_Pool } from './models.js';
+import { Tournament_TournamentSettings_Team } from './models.js';
+import { Tournament } from './models.js';
+import { Permissions } from './models.js';
+import { QualifierEvent_LeaderboardSort } from './models.js';
+import { QualifierEvent_EventSettings } from './models.js';
+import { Channel } from './discord.js';
+import { QualifierEvent } from './models.js';
+import { Map } from './models.js';
+import { Match } from './models.js';
+import { User } from './models.js';
+/**
+ * ---- Requests (GET (or do?) something where you need a response!) ---- //
+ *
+ * @generated from protobuf message proto.packets.Request
+ */
+export interface Request {
+    /**
+     * @generated from protobuf oneof: type
+     */
+    type: {
+        oneofKind: "updateUser";
+        /**
+         * @generated from protobuf field: proto.packets.Request.UpdateUser update_user = 1;
+         */
+        updateUser: Request_UpdateUser;
+    } | {
+        oneofKind: "createMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Request.CreateMatch create_match = 2;
+         */
+        createMatch: Request_CreateMatch;
+    } | {
+        oneofKind: "addUserToMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddUserToMatch add_user_to_match = 3;
+         */
+        addUserToMatch: Request_AddUserToMatch;
+    } | {
+        oneofKind: "removeUserFromMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveUserFromMatch remove_user_from_match = 4;
+         */
+        removeUserFromMatch: Request_RemoveUserFromMatch;
+    } | {
+        oneofKind: "setMatchLeader";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetMatchLeader set_match_leader = 5;
+         */
+        setMatchLeader: Request_SetMatchLeader;
+    } | {
+        oneofKind: "setMatchMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetMatchMap set_match_map = 6;
+         */
+        setMatchMap: Request_SetMatchMap;
+    } | {
+        oneofKind: "deleteMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Request.DeleteMatch delete_match = 7;
+         */
+        deleteMatch: Request_DeleteMatch;
+    } | {
+        oneofKind: "createQualifierEvent";
+        /**
+         * @generated from protobuf field: proto.packets.Request.CreateQualifierEvent create_qualifier_event = 8;
+         */
+        createQualifierEvent: Request_CreateQualifierEvent;
+    } | {
+        oneofKind: "setQualifierName";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetQualifierName set_qualifier_name = 9;
+         */
+        setQualifierName: Request_SetQualifierName;
+    } | {
+        oneofKind: "setQualifierInfoChannel";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetQualifierInfoChannel set_qualifier_info_channel = 10;
+         */
+        setQualifierInfoChannel: Request_SetQualifierInfoChannel;
+    } | {
+        oneofKind: "setQualifierImage";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetQualifierImage set_qualifier_image = 11;
+         */
+        setQualifierImage: Request_SetQualifierImage;
+    } | {
+        oneofKind: "setQualifierFlags";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetQualifierFlags set_qualifier_flags = 12;
+         */
+        setQualifierFlags: Request_SetQualifierFlags;
+    } | {
+        oneofKind: "setQualifierLeaderboardSort";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetQualifierLeaderboardSort set_qualifier_leaderboard_sort = 13;
+         */
+        setQualifierLeaderboardSort: Request_SetQualifierLeaderboardSort;
+    } | {
+        oneofKind: "addQualifierMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddQualifierMap add_qualifier_map = 14;
+         */
+        addQualifierMap: Request_AddQualifierMap;
+    } | {
+        oneofKind: "updateQualifierMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.UpdateQualifierMap update_qualifier_map = 15;
+         */
+        updateQualifierMap: Request_UpdateQualifierMap;
+    } | {
+        oneofKind: "removeQualifierMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveQualifierMap remove_qualifier_map = 16;
+         */
+        removeQualifierMap: Request_RemoveQualifierMap;
+    } | {
+        oneofKind: "deleteQualifierEvent";
+        /**
+         * @generated from protobuf field: proto.packets.Request.DeleteQualifierEvent delete_qualifier_event = 17;
+         */
+        deleteQualifierEvent: Request_DeleteQualifierEvent;
+    } | {
+        oneofKind: "addAuthorizedUser";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddAuthorizedUser add_authorized_user = 48;
+         */
+        addAuthorizedUser: Request_AddAuthorizedUser;
+    } | {
+        oneofKind: "addAuthorizedUserPermission";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddAuthorizedUserPermission add_authorized_user_permission = 49;
+         */
+        addAuthorizedUserPermission: Request_AddAuthorizedUserPermission;
+    } | {
+        oneofKind: "removeAuthorizedUserPermission";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveAuthorizedUserPermission remove_authorized_user_permission = 50;
+         */
+        removeAuthorizedUserPermission: Request_RemoveAuthorizedUserPermission;
+    } | {
+        oneofKind: "removeAuthorizedUser";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveAuthorizedUser remove_authorized_user = 51;
+         */
+        removeAuthorizedUser: Request_RemoveAuthorizedUser;
+    } | {
+        oneofKind: "getAuthorizedUsers";
+        /**
+         * @generated from protobuf field: proto.packets.Request.GetAuthorizedUsers get_authorized_users = 52;
+         */
+        getAuthorizedUsers: Request_GetAuthorizedUsers;
+    } | {
+        oneofKind: "getDiscordInfo";
+        /**
+         * @generated from protobuf field: proto.packets.Request.GetDiscordInfo get_discord_info = 53;
+         */
+        getDiscordInfo: Request_GetDiscordInfo;
+    } | {
+        oneofKind: "createTournament";
+        /**
+         * @generated from protobuf field: proto.packets.Request.CreateTournament create_tournament = 18;
+         */
+        createTournament: Request_CreateTournament;
+    } | {
+        oneofKind: "setTournamentName";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentName set_tournament_name = 19;
+         */
+        setTournamentName: Request_SetTournamentName;
+    } | {
+        oneofKind: "setTournamentImage";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentImage set_tournament_image = 20;
+         */
+        setTournamentImage: Request_SetTournamentImage;
+    } | {
+        oneofKind: "setTournamentEnableTeams";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentEnableTeams set_tournament_enable_teams = 21;
+         */
+        setTournamentEnableTeams: Request_SetTournamentEnableTeams;
+    } | {
+        oneofKind: "setTournamentEnablePools";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentEnablePools set_tournament_enable_pools = 44;
+         */
+        setTournamentEnablePools: Request_SetTournamentEnablePools;
+    } | {
+        oneofKind: "setTournamentShowTournamentButton";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentShowTournamentButton set_tournament_show_tournament_button = 45;
+         */
+        setTournamentShowTournamentButton: Request_SetTournamentShowTournamentButton;
+    } | {
+        oneofKind: "setTournamentShowQualifierButton";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentShowQualifierButton set_tournament_show_qualifier_button = 46;
+         */
+        setTournamentShowQualifierButton: Request_SetTournamentShowQualifierButton;
+    } | {
+        oneofKind: "setTournamentAllowUnauthorizedView";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentAllowUnauthorizedView set_tournament_allow_unauthorized_view = 54;
+         */
+        setTournamentAllowUnauthorizedView: Request_SetTournamentAllowUnauthorizedView;
+    } | {
+        oneofKind: "setTournamentScoreUpdateFrequency";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentScoreUpdateFrequency set_tournament_score_update_frequency = 47;
+         */
+        setTournamentScoreUpdateFrequency: Request_SetTournamentScoreUpdateFrequency;
+    } | {
+        oneofKind: "setTournamentBannedMods";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentBannedMods set_tournament_banned_mods = 23;
+         */
+        setTournamentBannedMods: Request_SetTournamentBannedMods;
+    } | {
+        oneofKind: "addTournamentTeam";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddTournamentTeam add_tournament_team = 24;
+         */
+        addTournamentTeam: Request_AddTournamentTeam;
+    } | {
+        oneofKind: "setTournamentTeamName";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentTeamName set_tournament_team_name = 25;
+         */
+        setTournamentTeamName: Request_SetTournamentTeamName;
+    } | {
+        oneofKind: "setTournamentTeamImage";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentTeamImage set_tournament_team_image = 26;
+         */
+        setTournamentTeamImage: Request_SetTournamentTeamImage;
+    } | {
+        oneofKind: "removeTournamentTeam";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveTournamentTeam remove_tournament_team = 27;
+         */
+        removeTournamentTeam: Request_RemoveTournamentTeam;
+    } | {
+        oneofKind: "addTournamentPool";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddTournamentPool add_tournament_pool = 28;
+         */
+        addTournamentPool: Request_AddTournamentPool;
+    } | {
+        oneofKind: "setTournamentPoolName";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SetTournamentPoolName set_tournament_pool_name = 29;
+         */
+        setTournamentPoolName: Request_SetTournamentPoolName;
+    } | {
+        oneofKind: "addTournamentPoolMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddTournamentPoolMap add_tournament_pool_map = 30;
+         */
+        addTournamentPoolMap: Request_AddTournamentPoolMap;
+    } | {
+        oneofKind: "updateTournamentPoolMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.UpdateTournamentPoolMap update_tournament_pool_map = 31;
+         */
+        updateTournamentPoolMap: Request_UpdateTournamentPoolMap;
+    } | {
+        oneofKind: "removeTournamentPoolMap";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveTournamentPoolMap remove_tournament_pool_map = 32;
+         */
+        removeTournamentPoolMap: Request_RemoveTournamentPoolMap;
+    } | {
+        oneofKind: "removeTournamentPool";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemoveTournamentPool remove_tournament_pool = 33;
+         */
+        removeTournamentPool: Request_RemoveTournamentPool;
+    } | {
+        oneofKind: "deleteTournament";
+        /**
+         * @generated from protobuf field: proto.packets.Request.DeleteTournament delete_tournament = 34;
+         */
+        deleteTournament: Request_DeleteTournament;
+    } | {
+        oneofKind: "addServer";
+        /**
+         * @generated from protobuf field: proto.packets.Request.AddServer add_server = 35;
+         */
+        addServer: Request_AddServer;
+    } | {
+        oneofKind: "connect";
+        /**
+         * @generated from protobuf field: proto.packets.Request.Connect connect = 36;
+         */
+        connect: Request_Connect;
+    } | {
+        oneofKind: "join";
+        /**
+         * @generated from protobuf field: proto.packets.Request.Join join = 37;
+         */
+        join: Request_Join;
+    } | {
+        oneofKind: "qualifierScores";
+        /**
+         * @generated from protobuf field: proto.packets.Request.QualifierScores qualifier_scores = 38;
+         */
+        qualifierScores: Request_QualifierScores;
+    } | {
+        oneofKind: "submitQualifierScore";
+        /**
+         * @generated from protobuf field: proto.packets.Request.SubmitQualifierScore submit_qualifier_score = 39;
+         */
+        submitQualifierScore: Request_SubmitQualifierScore;
+    } | {
+        oneofKind: "loadSong";
+        /**
+         * @generated from protobuf field: proto.packets.Request.LoadSong load_song = 40;
+         */
+        loadSong: Request_LoadSong;
+    } | {
+        oneofKind: "preloadImageForStreamSync";
+        /**
+         * @generated from protobuf field: proto.packets.Request.PreloadImageForStreamSync preload_image_for_stream_sync = 41;
+         */
+        preloadImageForStreamSync: Request_PreloadImageForStreamSync;
+    } | {
+        oneofKind: "showModal";
+        /**
+         * @generated from protobuf field: proto.packets.Request.ShowModal show_modal = 42;
+         */
+        showModal: Request_ShowModal;
+    } | {
+        oneofKind: "remainingAttempts";
+        /**
+         * @generated from protobuf field: proto.packets.Request.RemainingAttempts remaining_attempts = 43;
+         */
+        remainingAttempts: Request_RemainingAttempts;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * --- State Update Requests ---//
+ *
+ * @generated from protobuf message proto.packets.Request.UpdateUser
+ */
+export interface Request_UpdateUser {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.User user = 2;
+     */
+    user?: User;
+}
+/**
+ * -- Match -- //
+ *
+ * @generated from protobuf message proto.packets.Request.CreateMatch
+ */
+export interface Request_CreateMatch {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.AddUserToMatch
+ */
+export interface Request_AddUserToMatch {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string match_id = 2;
+     */
+    matchId: string;
+    /**
+     * @generated from protobuf field: string user_id = 3;
+     */
+    userId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveUserFromMatch
+ */
+export interface Request_RemoveUserFromMatch {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string match_id = 2;
+     */
+    matchId: string;
+    /**
+     * @generated from protobuf field: string user_id = 3;
+     */
+    userId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetMatchLeader
+ */
+export interface Request_SetMatchLeader {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string match_id = 2;
+     */
+    matchId: string;
+    /**
+     * @generated from protobuf field: string user_id = 3;
+     */
+    userId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetMatchMap
+ */
+export interface Request_SetMatchMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string match_id = 2;
+     */
+    matchId: string;
+    /**
+     * @generated from protobuf field: proto.models.Map map = 3;
+     */
+    map?: Map;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.DeleteMatch
+ */
+export interface Request_DeleteMatch {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string match_id = 2;
+     */
+    matchId: string;
+}
+/**
+ * -- Qualifiers -- //
+ *
+ * @generated from protobuf message proto.packets.Request.CreateQualifierEvent
+ */
+export interface Request_CreateQualifierEvent {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent event = 2;
+     */
+    event?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetQualifierName
+ */
+export interface Request_SetQualifierName {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: string qualifier_name = 3;
+     */
+    qualifierName: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetQualifierImage
+ */
+export interface Request_SetQualifierImage {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: bytes qualifier_image = 3;
+     */
+    qualifierImage: Uint8Array;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetQualifierInfoChannel
+ */
+export interface Request_SetQualifierInfoChannel {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: proto.discord.Channel info_channel = 3;
+     */
+    infoChannel?: Channel;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetQualifierFlags
+ */
+export interface Request_SetQualifierFlags {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent.EventSettings qualifier_flags = 3;
+     */
+    qualifierFlags: QualifierEvent_EventSettings;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetQualifierLeaderboardSort
+ */
+export interface Request_SetQualifierLeaderboardSort {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent.LeaderboardSort qualifier_leaderboard_sort = 3;
+     */
+    qualifierLeaderboardSort: QualifierEvent_LeaderboardSort;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.AddQualifierMap
+ */
+export interface Request_AddQualifierMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: proto.models.Map map = 3;
+     */
+    map?: Map;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.UpdateQualifierMap
+ */
+export interface Request_UpdateQualifierMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: proto.models.Map map = 3;
+     */
+    map?: Map;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveQualifierMap
+ */
+export interface Request_RemoveQualifierMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+    /**
+     * @generated from protobuf field: string map_id = 3;
+     */
+    mapId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.DeleteQualifierEvent
+ */
+export interface Request_DeleteQualifierEvent {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string qualifier_id = 2;
+     */
+    qualifierId: string;
+}
+/**
+ * -- Tournament -- //
+ *
+ * @generated from protobuf message proto.packets.Request.AddAuthorizedUser
+ */
+export interface Request_AddAuthorizedUser {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string discord_id = 2;
+     */
+    discordId: string;
+    /**
+     * @generated from protobuf field: proto.models.Permissions permission_flags = 3;
+     */
+    permissionFlags: Permissions;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.AddAuthorizedUserPermission
+ */
+export interface Request_AddAuthorizedUserPermission {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string discord_id = 2;
+     */
+    discordId: string;
+    /**
+     * @generated from protobuf field: proto.models.Permissions permission = 3;
+     */
+    permission: Permissions;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveAuthorizedUserPermission
+ */
+export interface Request_RemoveAuthorizedUserPermission {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string discord_id = 2;
+     */
+    discordId: string;
+    /**
+     * @generated from protobuf field: proto.models.Permissions permission = 3;
+     */
+    permission: Permissions;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveAuthorizedUser
+ */
+export interface Request_RemoveAuthorizedUser {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string discord_id = 2;
+     */
+    discordId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.GetAuthorizedUsers
+ */
+export interface Request_GetAuthorizedUsers {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.GetDiscordInfo
+ */
+export interface Request_GetDiscordInfo {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string; // Included so this request can be permission gated to a tourney
+    /**
+     * @generated from protobuf field: string discord_id = 2;
+     */
+    discordId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.CreateTournament
+ */
+export interface Request_CreateTournament {
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 1;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentName
+ */
+export interface Request_SetTournamentName {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string tournament_name = 2;
+     */
+    tournamentName: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentImage
+ */
+export interface Request_SetTournamentImage {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: bytes tournament_image = 2;
+     */
+    tournamentImage: Uint8Array;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentEnableTeams
+ */
+export interface Request_SetTournamentEnableTeams {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: bool enable_teams = 2;
+     */
+    enableTeams: boolean;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentEnablePools
+ */
+export interface Request_SetTournamentEnablePools {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: bool enable_pools = 2;
+     */
+    enablePools: boolean;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentShowTournamentButton
+ */
+export interface Request_SetTournamentShowTournamentButton {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: bool show_tournament_button = 2;
+     */
+    showTournamentButton: boolean;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentShowQualifierButton
+ */
+export interface Request_SetTournamentShowQualifierButton {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: bool show_qualifier_button = 2;
+     */
+    showQualifierButton: boolean;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentAllowUnauthorizedView
+ */
+export interface Request_SetTournamentAllowUnauthorizedView {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: bool allow_unauthorized_view = 2;
+     */
+    allowUnauthorizedView: boolean;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentScoreUpdateFrequency
+ */
+export interface Request_SetTournamentScoreUpdateFrequency {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: int32 score_update_frequency = 2;
+     */
+    scoreUpdateFrequency: number;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentBannedMods
+ */
+export interface Request_SetTournamentBannedMods {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: repeated string banned_mods = 2;
+     */
+    bannedMods: string[];
+}
+/**
+ * @generated from protobuf message proto.packets.Request.AddTournamentTeam
+ */
+export interface Request_AddTournamentTeam {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.Tournament.TournamentSettings.Team team = 2;
+     */
+    team?: Tournament_TournamentSettings_Team;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentTeamName
+ */
+export interface Request_SetTournamentTeamName {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string team_id = 2;
+     */
+    teamId: string;
+    /**
+     * @generated from protobuf field: string team_name = 3;
+     */
+    teamName: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentTeamImage
+ */
+export interface Request_SetTournamentTeamImage {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string team_id = 2;
+     */
+    teamId: string;
+    /**
+     * @generated from protobuf field: bytes team_image = 3;
+     */
+    teamImage: Uint8Array;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveTournamentTeam
+ */
+export interface Request_RemoveTournamentTeam {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string team_id = 2;
+     */
+    teamId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.AddTournamentPool
+ */
+export interface Request_AddTournamentPool {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.Tournament.TournamentSettings.Pool pool = 2;
+     */
+    pool?: Tournament_TournamentSettings_Pool;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SetTournamentPoolName
+ */
+export interface Request_SetTournamentPoolName {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string pool_id = 2;
+     */
+    poolId: string;
+    /**
+     * @generated from protobuf field: string pool_name = 3;
+     */
+    poolName: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.AddTournamentPoolMap
+ */
+export interface Request_AddTournamentPoolMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string pool_id = 2;
+     */
+    poolId: string;
+    /**
+     * @generated from protobuf field: proto.models.Map map = 3;
+     */
+    map?: Map;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.UpdateTournamentPoolMap
+ */
+export interface Request_UpdateTournamentPoolMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string pool_id = 2;
+     */
+    poolId: string;
+    /**
+     * @generated from protobuf field: proto.models.Map map = 3;
+     */
+    map?: Map;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveTournamentPoolMap
+ */
+export interface Request_RemoveTournamentPoolMap {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string pool_id = 2;
+     */
+    poolId: string;
+    /**
+     * @generated from protobuf field: string map_id = 3;
+     */
+    mapId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemoveTournamentPool
+ */
+export interface Request_RemoveTournamentPool {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string pool_id = 2;
+     */
+    poolId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.DeleteTournament
+ */
+export interface Request_DeleteTournament {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+}
+/**
+ * -- Server -- //
+ *
+ * @generated from protobuf message proto.packets.Request.AddServer
+ */
+export interface Request_AddServer {
+    /**
+     * @generated from protobuf field: proto.models.CoreServer server = 1;
+     */
+    server?: CoreServer;
+    /**
+     * @generated from protobuf field: string auth_token = 2;
+     */
+    authToken: string;
+}
+// Probably not needed? If someone wants to remove their server from the list, they can just shut it down
+// message DeleteServer {
+//   models.CoreServer server = 1;
+//   string auth_token = 2;
+// }
+
+/**
+ * -- Other Requests -- //
+ *
+ * @generated from protobuf message proto.packets.Request.Connect
+ */
+export interface Request_Connect {
+    /**
+     * @generated from protobuf field: int32 client_version = 1;
+     */
+    clientVersion: number;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.Join
+ */
+export interface Request_Join {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string password = 2;
+     */
+    password: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.QualifierScores
+ */
+export interface Request_QualifierScores {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string; // Included so this request can be permission gated to a tourney
+    /**
+     * @generated from protobuf field: string event_id = 2;
+     */
+    eventId: string;
+    /**
+     * @generated from protobuf field: string map_id = 3;
+     */
+    mapId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.SubmitQualifierScore
+ */
+export interface Request_SubmitQualifierScore {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string; // Included so this request can be permission gated to a tourney
+    /**
+     * @generated from protobuf field: proto.models.LeaderboardEntry qualifier_score = 2;
+     */
+    qualifierScore?: LeaderboardEntry;
+    /**
+     * @generated from protobuf field: proto.models.GameplayParameters map = 3;
+     */
+    map?: GameplayParameters;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.LoadSong
+ */
+export interface Request_LoadSong {
+    /**
+     * @generated from protobuf field: string level_id = 1;
+     */
+    levelId: string;
+    /**
+     * @generated from protobuf field: string custom_host_url = 2;
+     */
+    customHostUrl: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.PreloadImageForStreamSync
+ */
+export interface Request_PreloadImageForStreamSync {
+    /**
+     * @generated from protobuf field: string file_id = 1;
+     */
+    fileId: string;
+    /**
+     * @generated from protobuf field: bool compressed = 2;
+     */
+    compressed: boolean;
+    /**
+     * @generated from protobuf field: bytes data = 3;
+     */
+    data: Uint8Array;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.ShowModal
+ */
+export interface Request_ShowModal {
+    /**
+     * @generated from protobuf field: string modal_id = 1;
+     */
+    modalId: string;
+    /**
+     * @generated from protobuf field: string message_title = 2;
+     */
+    messageTitle: string;
+    /**
+     * @generated from protobuf field: string message_text = 3;
+     */
+    messageText: string;
+    /**
+     * @generated from protobuf field: bool can_close = 4;
+     */
+    canClose: boolean;
+    /**
+     * @generated from protobuf field: proto.models.ModalOption option_1 = 5;
+     */
+    option1?: ModalOption;
+    /**
+     * @generated from protobuf field: proto.models.ModalOption option_2 = 6;
+     */
+    option2?: ModalOption;
+}
+/**
+ * @generated from protobuf message proto.packets.Request.RemainingAttempts
+ */
+export interface Request_RemainingAttempts {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string; // Included so this request can be permission gated to a tourney
+    /**
+     * @generated from protobuf field: string event_id = 2;
+     */
+    eventId: string;
+    /**
+     * @generated from protobuf field: string map_id = 3;
+     */
+    mapId: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Request$Type extends MessageType<Request> {
+    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 },
+            { no: 11, name: "set_qualifier_image", kind: "message", oneof: "type", T: () => Request_SetQualifierImage },
+            { no: 12, name: "set_qualifier_flags", kind: "message", oneof: "type", T: () => Request_SetQualifierFlags },
+            { no: 13, name: "set_qualifier_leaderboard_sort", kind: "message", oneof: "type", T: () => Request_SetQualifierLeaderboardSort },
+            { no: 14, name: "add_qualifier_map", kind: "message", oneof: "type", T: () => Request_AddQualifierMap },
+            { no: 15, name: "update_qualifier_map", kind: "message", oneof: "type", T: () => Request_UpdateQualifierMap },
+            { no: 16, name: "remove_qualifier_map", kind: "message", oneof: "type", T: () => Request_RemoveQualifierMap },
+            { no: 17, name: "delete_qualifier_event", kind: "message", oneof: "type", T: () => Request_DeleteQualifierEvent },
+            { no: 48, name: "add_authorized_user", kind: "message", oneof: "type", T: () => Request_AddAuthorizedUser },
+            { no: 49, name: "add_authorized_user_permission", kind: "message", oneof: "type", T: () => Request_AddAuthorizedUserPermission },
+            { no: 50, name: "remove_authorized_user_permission", kind: "message", oneof: "type", T: () => Request_RemoveAuthorizedUserPermission },
+            { no: 51, name: "remove_authorized_user", kind: "message", oneof: "type", T: () => Request_RemoveAuthorizedUser },
+            { no: 52, name: "get_authorized_users", kind: "message", oneof: "type", T: () => Request_GetAuthorizedUsers },
+            { no: 53, name: "get_discord_info", kind: "message", oneof: "type", T: () => Request_GetDiscordInfo },
+            { no: 18, name: "create_tournament", kind: "message", oneof: "type", T: () => Request_CreateTournament },
+            { no: 19, name: "set_tournament_name", kind: "message", oneof: "type", T: () => Request_SetTournamentName },
+            { no: 20, name: "set_tournament_image", kind: "message", oneof: "type", T: () => Request_SetTournamentImage },
+            { no: 21, name: "set_tournament_enable_teams", kind: "message", oneof: "type", T: () => Request_SetTournamentEnableTeams },
+            { no: 44, name: "set_tournament_enable_pools", kind: "message", oneof: "type", T: () => Request_SetTournamentEnablePools },
+            { no: 45, name: "set_tournament_show_tournament_button", kind: "message", oneof: "type", T: () => Request_SetTournamentShowTournamentButton },
+            { no: 46, name: "set_tournament_show_qualifier_button", kind: "message", oneof: "type", T: () => Request_SetTournamentShowQualifierButton },
+            { no: 54, name: "set_tournament_allow_unauthorized_view", kind: "message", oneof: "type", T: () => Request_SetTournamentAllowUnauthorizedView },
+            { no: 47, name: "set_tournament_score_update_frequency", kind: "message", oneof: "type", T: () => Request_SetTournamentScoreUpdateFrequency },
+            { no: 23, name: "set_tournament_banned_mods", kind: "message", oneof: "type", T: () => Request_SetTournamentBannedMods },
+            { no: 24, name: "add_tournament_team", kind: "message", oneof: "type", T: () => Request_AddTournamentTeam },
+            { no: 25, name: "set_tournament_team_name", kind: "message", oneof: "type", T: () => Request_SetTournamentTeamName },
+            { no: 26, name: "set_tournament_team_image", kind: "message", oneof: "type", T: () => Request_SetTournamentTeamImage },
+            { no: 27, name: "remove_tournament_team", kind: "message", oneof: "type", T: () => Request_RemoveTournamentTeam },
+            { no: 28, name: "add_tournament_pool", kind: "message", oneof: "type", T: () => Request_AddTournamentPool },
+            { no: 29, name: "set_tournament_pool_name", kind: "message", oneof: "type", T: () => Request_SetTournamentPoolName },
+            { no: 30, name: "add_tournament_pool_map", kind: "message", oneof: "type", T: () => Request_AddTournamentPoolMap },
+            { no: 31, name: "update_tournament_pool_map", kind: "message", oneof: "type", T: () => Request_UpdateTournamentPoolMap },
+            { no: 32, name: "remove_tournament_pool_map", kind: "message", oneof: "type", T: () => Request_RemoveTournamentPoolMap },
+            { no: 33, name: "remove_tournament_pool", kind: "message", oneof: "type", T: () => Request_RemoveTournamentPool },
+            { no: 34, name: "delete_tournament", kind: "message", oneof: "type", T: () => Request_DeleteTournament },
+            { no: 35, name: "add_server", kind: "message", oneof: "type", T: () => Request_AddServer },
+            { no: 36, name: "connect", kind: "message", oneof: "type", T: () => Request_Connect },
+            { no: 37, name: "join", kind: "message", oneof: "type", T: () => Request_Join },
+            { no: 38, name: "qualifier_scores", kind: "message", oneof: "type", T: () => Request_QualifierScores },
+            { no: 39, name: "submit_qualifier_score", kind: "message", oneof: "type", T: () => Request_SubmitQualifierScore },
+            { no: 40, name: "load_song", kind: "message", oneof: "type", T: () => Request_LoadSong },
+            { no: 41, name: "preload_image_for_stream_sync", kind: "message", oneof: "type", T: () => Request_PreloadImageForStreamSync },
+            { no: 42, name: "show_modal", kind: "message", oneof: "type", T: () => Request_ShowModal },
+            { no: 43, name: "remaining_attempts", kind: "message", oneof: "type", T: () => Request_RemainingAttempts }
+        ]);
+    }
+    create(value?: PartialMessage<Request>): Request {
+        const message = { type: { oneofKind: undefined } };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request): Request {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.packets.Request.UpdateUser update_user */ 1:
+                    message.type = {
+                        oneofKind: "updateUser",
+                        updateUser: Request_UpdateUser.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).updateUser)
+                    };
+                    break;
+                case /* proto.packets.Request.CreateMatch create_match */ 2:
+                    message.type = {
+                        oneofKind: "createMatch",
+                        createMatch: Request_CreateMatch.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).createMatch)
+                    };
+                    break;
+                case /* proto.packets.Request.AddUserToMatch add_user_to_match */ 3:
+                    message.type = {
+                        oneofKind: "addUserToMatch",
+                        addUserToMatch: Request_AddUserToMatch.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addUserToMatch)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveUserFromMatch remove_user_from_match */ 4:
+                    message.type = {
+                        oneofKind: "removeUserFromMatch",
+                        removeUserFromMatch: Request_RemoveUserFromMatch.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeUserFromMatch)
+                    };
+                    break;
+                case /* proto.packets.Request.SetMatchLeader set_match_leader */ 5:
+                    message.type = {
+                        oneofKind: "setMatchLeader",
+                        setMatchLeader: Request_SetMatchLeader.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setMatchLeader)
+                    };
+                    break;
+                case /* proto.packets.Request.SetMatchMap set_match_map */ 6:
+                    message.type = {
+                        oneofKind: "setMatchMap",
+                        setMatchMap: Request_SetMatchMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setMatchMap)
+                    };
+                    break;
+                case /* proto.packets.Request.DeleteMatch delete_match */ 7:
+                    message.type = {
+                        oneofKind: "deleteMatch",
+                        deleteMatch: Request_DeleteMatch.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).deleteMatch)
+                    };
+                    break;
+                case /* proto.packets.Request.CreateQualifierEvent create_qualifier_event */ 8:
+                    message.type = {
+                        oneofKind: "createQualifierEvent",
+                        createQualifierEvent: Request_CreateQualifierEvent.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).createQualifierEvent)
+                    };
+                    break;
+                case /* proto.packets.Request.SetQualifierName set_qualifier_name */ 9:
+                    message.type = {
+                        oneofKind: "setQualifierName",
+                        setQualifierName: Request_SetQualifierName.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setQualifierName)
+                    };
+                    break;
+                case /* proto.packets.Request.SetQualifierInfoChannel set_qualifier_info_channel */ 10:
+                    message.type = {
+                        oneofKind: "setQualifierInfoChannel",
+                        setQualifierInfoChannel: Request_SetQualifierInfoChannel.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setQualifierInfoChannel)
+                    };
+                    break;
+                case /* proto.packets.Request.SetQualifierImage set_qualifier_image */ 11:
+                    message.type = {
+                        oneofKind: "setQualifierImage",
+                        setQualifierImage: Request_SetQualifierImage.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setQualifierImage)
+                    };
+                    break;
+                case /* proto.packets.Request.SetQualifierFlags set_qualifier_flags */ 12:
+                    message.type = {
+                        oneofKind: "setQualifierFlags",
+                        setQualifierFlags: Request_SetQualifierFlags.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setQualifierFlags)
+                    };
+                    break;
+                case /* proto.packets.Request.SetQualifierLeaderboardSort set_qualifier_leaderboard_sort */ 13:
+                    message.type = {
+                        oneofKind: "setQualifierLeaderboardSort",
+                        setQualifierLeaderboardSort: Request_SetQualifierLeaderboardSort.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setQualifierLeaderboardSort)
+                    };
+                    break;
+                case /* proto.packets.Request.AddQualifierMap add_qualifier_map */ 14:
+                    message.type = {
+                        oneofKind: "addQualifierMap",
+                        addQualifierMap: Request_AddQualifierMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addQualifierMap)
+                    };
+                    break;
+                case /* proto.packets.Request.UpdateQualifierMap update_qualifier_map */ 15:
+                    message.type = {
+                        oneofKind: "updateQualifierMap",
+                        updateQualifierMap: Request_UpdateQualifierMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).updateQualifierMap)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveQualifierMap remove_qualifier_map */ 16:
+                    message.type = {
+                        oneofKind: "removeQualifierMap",
+                        removeQualifierMap: Request_RemoveQualifierMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeQualifierMap)
+                    };
+                    break;
+                case /* proto.packets.Request.DeleteQualifierEvent delete_qualifier_event */ 17:
+                    message.type = {
+                        oneofKind: "deleteQualifierEvent",
+                        deleteQualifierEvent: Request_DeleteQualifierEvent.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).deleteQualifierEvent)
+                    };
+                    break;
+                case /* proto.packets.Request.AddAuthorizedUser add_authorized_user */ 48:
+                    message.type = {
+                        oneofKind: "addAuthorizedUser",
+                        addAuthorizedUser: Request_AddAuthorizedUser.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addAuthorizedUser)
+                    };
+                    break;
+                case /* proto.packets.Request.AddAuthorizedUserPermission add_authorized_user_permission */ 49:
+                    message.type = {
+                        oneofKind: "addAuthorizedUserPermission",
+                        addAuthorizedUserPermission: Request_AddAuthorizedUserPermission.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addAuthorizedUserPermission)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveAuthorizedUserPermission remove_authorized_user_permission */ 50:
+                    message.type = {
+                        oneofKind: "removeAuthorizedUserPermission",
+                        removeAuthorizedUserPermission: Request_RemoveAuthorizedUserPermission.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeAuthorizedUserPermission)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveAuthorizedUser remove_authorized_user */ 51:
+                    message.type = {
+                        oneofKind: "removeAuthorizedUser",
+                        removeAuthorizedUser: Request_RemoveAuthorizedUser.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeAuthorizedUser)
+                    };
+                    break;
+                case /* proto.packets.Request.GetAuthorizedUsers get_authorized_users */ 52:
+                    message.type = {
+                        oneofKind: "getAuthorizedUsers",
+                        getAuthorizedUsers: Request_GetAuthorizedUsers.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).getAuthorizedUsers)
+                    };
+                    break;
+                case /* proto.packets.Request.GetDiscordInfo get_discord_info */ 53:
+                    message.type = {
+                        oneofKind: "getDiscordInfo",
+                        getDiscordInfo: Request_GetDiscordInfo.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).getDiscordInfo)
+                    };
+                    break;
+                case /* proto.packets.Request.CreateTournament create_tournament */ 18:
+                    message.type = {
+                        oneofKind: "createTournament",
+                        createTournament: Request_CreateTournament.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).createTournament)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentName set_tournament_name */ 19:
+                    message.type = {
+                        oneofKind: "setTournamentName",
+                        setTournamentName: Request_SetTournamentName.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentName)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentImage set_tournament_image */ 20:
+                    message.type = {
+                        oneofKind: "setTournamentImage",
+                        setTournamentImage: Request_SetTournamentImage.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentImage)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentEnableTeams set_tournament_enable_teams */ 21:
+                    message.type = {
+                        oneofKind: "setTournamentEnableTeams",
+                        setTournamentEnableTeams: Request_SetTournamentEnableTeams.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentEnableTeams)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentEnablePools set_tournament_enable_pools */ 44:
+                    message.type = {
+                        oneofKind: "setTournamentEnablePools",
+                        setTournamentEnablePools: Request_SetTournamentEnablePools.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentEnablePools)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentShowTournamentButton set_tournament_show_tournament_button */ 45:
+                    message.type = {
+                        oneofKind: "setTournamentShowTournamentButton",
+                        setTournamentShowTournamentButton: Request_SetTournamentShowTournamentButton.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentShowTournamentButton)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentShowQualifierButton set_tournament_show_qualifier_button */ 46:
+                    message.type = {
+                        oneofKind: "setTournamentShowQualifierButton",
+                        setTournamentShowQualifierButton: Request_SetTournamentShowQualifierButton.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentShowQualifierButton)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentAllowUnauthorizedView set_tournament_allow_unauthorized_view */ 54:
+                    message.type = {
+                        oneofKind: "setTournamentAllowUnauthorizedView",
+                        setTournamentAllowUnauthorizedView: Request_SetTournamentAllowUnauthorizedView.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentAllowUnauthorizedView)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentScoreUpdateFrequency set_tournament_score_update_frequency */ 47:
+                    message.type = {
+                        oneofKind: "setTournamentScoreUpdateFrequency",
+                        setTournamentScoreUpdateFrequency: Request_SetTournamentScoreUpdateFrequency.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentScoreUpdateFrequency)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentBannedMods set_tournament_banned_mods */ 23:
+                    message.type = {
+                        oneofKind: "setTournamentBannedMods",
+                        setTournamentBannedMods: Request_SetTournamentBannedMods.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentBannedMods)
+                    };
+                    break;
+                case /* proto.packets.Request.AddTournamentTeam add_tournament_team */ 24:
+                    message.type = {
+                        oneofKind: "addTournamentTeam",
+                        addTournamentTeam: Request_AddTournamentTeam.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addTournamentTeam)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentTeamName set_tournament_team_name */ 25:
+                    message.type = {
+                        oneofKind: "setTournamentTeamName",
+                        setTournamentTeamName: Request_SetTournamentTeamName.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentTeamName)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentTeamImage set_tournament_team_image */ 26:
+                    message.type = {
+                        oneofKind: "setTournamentTeamImage",
+                        setTournamentTeamImage: Request_SetTournamentTeamImage.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentTeamImage)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveTournamentTeam remove_tournament_team */ 27:
+                    message.type = {
+                        oneofKind: "removeTournamentTeam",
+                        removeTournamentTeam: Request_RemoveTournamentTeam.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeTournamentTeam)
+                    };
+                    break;
+                case /* proto.packets.Request.AddTournamentPool add_tournament_pool */ 28:
+                    message.type = {
+                        oneofKind: "addTournamentPool",
+                        addTournamentPool: Request_AddTournamentPool.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addTournamentPool)
+                    };
+                    break;
+                case /* proto.packets.Request.SetTournamentPoolName set_tournament_pool_name */ 29:
+                    message.type = {
+                        oneofKind: "setTournamentPoolName",
+                        setTournamentPoolName: Request_SetTournamentPoolName.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).setTournamentPoolName)
+                    };
+                    break;
+                case /* proto.packets.Request.AddTournamentPoolMap add_tournament_pool_map */ 30:
+                    message.type = {
+                        oneofKind: "addTournamentPoolMap",
+                        addTournamentPoolMap: Request_AddTournamentPoolMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addTournamentPoolMap)
+                    };
+                    break;
+                case /* proto.packets.Request.UpdateTournamentPoolMap update_tournament_pool_map */ 31:
+                    message.type = {
+                        oneofKind: "updateTournamentPoolMap",
+                        updateTournamentPoolMap: Request_UpdateTournamentPoolMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).updateTournamentPoolMap)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveTournamentPoolMap remove_tournament_pool_map */ 32:
+                    message.type = {
+                        oneofKind: "removeTournamentPoolMap",
+                        removeTournamentPoolMap: Request_RemoveTournamentPoolMap.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeTournamentPoolMap)
+                    };
+                    break;
+                case /* proto.packets.Request.RemoveTournamentPool remove_tournament_pool */ 33:
+                    message.type = {
+                        oneofKind: "removeTournamentPool",
+                        removeTournamentPool: Request_RemoveTournamentPool.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).removeTournamentPool)
+                    };
+                    break;
+                case /* proto.packets.Request.DeleteTournament delete_tournament */ 34:
+                    message.type = {
+                        oneofKind: "deleteTournament",
+                        deleteTournament: Request_DeleteTournament.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).deleteTournament)
+                    };
+                    break;
+                case /* proto.packets.Request.AddServer add_server */ 35:
+                    message.type = {
+                        oneofKind: "addServer",
+                        addServer: Request_AddServer.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).addServer)
+                    };
+                    break;
+                case /* proto.packets.Request.Connect connect */ 36:
+                    message.type = {
+                        oneofKind: "connect",
+                        connect: Request_Connect.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).connect)
+                    };
+                    break;
+                case /* proto.packets.Request.Join join */ 37:
+                    message.type = {
+                        oneofKind: "join",
+                        join: Request_Join.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).join)
+                    };
+                    break;
+                case /* proto.packets.Request.QualifierScores qualifier_scores */ 38:
+                    message.type = {
+                        oneofKind: "qualifierScores",
+                        qualifierScores: Request_QualifierScores.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).qualifierScores)
+                    };
+                    break;
+                case /* proto.packets.Request.SubmitQualifierScore submit_qualifier_score */ 39:
+                    message.type = {
+                        oneofKind: "submitQualifierScore",
+                        submitQualifierScore: Request_SubmitQualifierScore.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).submitQualifierScore)
+                    };
+                    break;
+                case /* proto.packets.Request.LoadSong load_song */ 40:
+                    message.type = {
+                        oneofKind: "loadSong",
+                        loadSong: Request_LoadSong.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).loadSong)
+                    };
+                    break;
+                case /* proto.packets.Request.PreloadImageForStreamSync preload_image_for_stream_sync */ 41:
+                    message.type = {
+                        oneofKind: "preloadImageForStreamSync",
+                        preloadImageForStreamSync: Request_PreloadImageForStreamSync.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).preloadImageForStreamSync)
+                    };
+                    break;
+                case /* proto.packets.Request.ShowModal show_modal */ 42:
+                    message.type = {
+                        oneofKind: "showModal",
+                        showModal: Request_ShowModal.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).showModal)
+                    };
+                    break;
+                case /* proto.packets.Request.RemainingAttempts remaining_attempts */ 43:
+                    message.type = {
+                        oneofKind: "remainingAttempts",
+                        remainingAttempts: Request_RemainingAttempts.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).remainingAttempts)
+                    };
+                    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: Request, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.packets.Request.UpdateUser update_user = 1; */
+        if (message.type.oneofKind === "updateUser")
+            Request_UpdateUser.internalBinaryWrite(message.type.updateUser, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.CreateMatch create_match = 2; */
+        if (message.type.oneofKind === "createMatch")
+            Request_CreateMatch.internalBinaryWrite(message.type.createMatch, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddUserToMatch add_user_to_match = 3; */
+        if (message.type.oneofKind === "addUserToMatch")
+            Request_AddUserToMatch.internalBinaryWrite(message.type.addUserToMatch, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveUserFromMatch remove_user_from_match = 4; */
+        if (message.type.oneofKind === "removeUserFromMatch")
+            Request_RemoveUserFromMatch.internalBinaryWrite(message.type.removeUserFromMatch, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetMatchLeader set_match_leader = 5; */
+        if (message.type.oneofKind === "setMatchLeader")
+            Request_SetMatchLeader.internalBinaryWrite(message.type.setMatchLeader, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetMatchMap set_match_map = 6; */
+        if (message.type.oneofKind === "setMatchMap")
+            Request_SetMatchMap.internalBinaryWrite(message.type.setMatchMap, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.DeleteMatch delete_match = 7; */
+        if (message.type.oneofKind === "deleteMatch")
+            Request_DeleteMatch.internalBinaryWrite(message.type.deleteMatch, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.CreateQualifierEvent create_qualifier_event = 8; */
+        if (message.type.oneofKind === "createQualifierEvent")
+            Request_CreateQualifierEvent.internalBinaryWrite(message.type.createQualifierEvent, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetQualifierName set_qualifier_name = 9; */
+        if (message.type.oneofKind === "setQualifierName")
+            Request_SetQualifierName.internalBinaryWrite(message.type.setQualifierName, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetQualifierInfoChannel set_qualifier_info_channel = 10; */
+        if (message.type.oneofKind === "setQualifierInfoChannel")
+            Request_SetQualifierInfoChannel.internalBinaryWrite(message.type.setQualifierInfoChannel, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetQualifierImage set_qualifier_image = 11; */
+        if (message.type.oneofKind === "setQualifierImage")
+            Request_SetQualifierImage.internalBinaryWrite(message.type.setQualifierImage, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetQualifierFlags set_qualifier_flags = 12; */
+        if (message.type.oneofKind === "setQualifierFlags")
+            Request_SetQualifierFlags.internalBinaryWrite(message.type.setQualifierFlags, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetQualifierLeaderboardSort set_qualifier_leaderboard_sort = 13; */
+        if (message.type.oneofKind === "setQualifierLeaderboardSort")
+            Request_SetQualifierLeaderboardSort.internalBinaryWrite(message.type.setQualifierLeaderboardSort, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddQualifierMap add_qualifier_map = 14; */
+        if (message.type.oneofKind === "addQualifierMap")
+            Request_AddQualifierMap.internalBinaryWrite(message.type.addQualifierMap, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.UpdateQualifierMap update_qualifier_map = 15; */
+        if (message.type.oneofKind === "updateQualifierMap")
+            Request_UpdateQualifierMap.internalBinaryWrite(message.type.updateQualifierMap, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveQualifierMap remove_qualifier_map = 16; */
+        if (message.type.oneofKind === "removeQualifierMap")
+            Request_RemoveQualifierMap.internalBinaryWrite(message.type.removeQualifierMap, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.DeleteQualifierEvent delete_qualifier_event = 17; */
+        if (message.type.oneofKind === "deleteQualifierEvent")
+            Request_DeleteQualifierEvent.internalBinaryWrite(message.type.deleteQualifierEvent, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddAuthorizedUser add_authorized_user = 48; */
+        if (message.type.oneofKind === "addAuthorizedUser")
+            Request_AddAuthorizedUser.internalBinaryWrite(message.type.addAuthorizedUser, writer.tag(48, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddAuthorizedUserPermission add_authorized_user_permission = 49; */
+        if (message.type.oneofKind === "addAuthorizedUserPermission")
+            Request_AddAuthorizedUserPermission.internalBinaryWrite(message.type.addAuthorizedUserPermission, writer.tag(49, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveAuthorizedUserPermission remove_authorized_user_permission = 50; */
+        if (message.type.oneofKind === "removeAuthorizedUserPermission")
+            Request_RemoveAuthorizedUserPermission.internalBinaryWrite(message.type.removeAuthorizedUserPermission, writer.tag(50, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveAuthorizedUser remove_authorized_user = 51; */
+        if (message.type.oneofKind === "removeAuthorizedUser")
+            Request_RemoveAuthorizedUser.internalBinaryWrite(message.type.removeAuthorizedUser, writer.tag(51, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.GetAuthorizedUsers get_authorized_users = 52; */
+        if (message.type.oneofKind === "getAuthorizedUsers")
+            Request_GetAuthorizedUsers.internalBinaryWrite(message.type.getAuthorizedUsers, writer.tag(52, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.GetDiscordInfo get_discord_info = 53; */
+        if (message.type.oneofKind === "getDiscordInfo")
+            Request_GetDiscordInfo.internalBinaryWrite(message.type.getDiscordInfo, writer.tag(53, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.CreateTournament create_tournament = 18; */
+        if (message.type.oneofKind === "createTournament")
+            Request_CreateTournament.internalBinaryWrite(message.type.createTournament, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentName set_tournament_name = 19; */
+        if (message.type.oneofKind === "setTournamentName")
+            Request_SetTournamentName.internalBinaryWrite(message.type.setTournamentName, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentImage set_tournament_image = 20; */
+        if (message.type.oneofKind === "setTournamentImage")
+            Request_SetTournamentImage.internalBinaryWrite(message.type.setTournamentImage, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentEnableTeams set_tournament_enable_teams = 21; */
+        if (message.type.oneofKind === "setTournamentEnableTeams")
+            Request_SetTournamentEnableTeams.internalBinaryWrite(message.type.setTournamentEnableTeams, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentEnablePools set_tournament_enable_pools = 44; */
+        if (message.type.oneofKind === "setTournamentEnablePools")
+            Request_SetTournamentEnablePools.internalBinaryWrite(message.type.setTournamentEnablePools, writer.tag(44, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentShowTournamentButton set_tournament_show_tournament_button = 45; */
+        if (message.type.oneofKind === "setTournamentShowTournamentButton")
+            Request_SetTournamentShowTournamentButton.internalBinaryWrite(message.type.setTournamentShowTournamentButton, writer.tag(45, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentShowQualifierButton set_tournament_show_qualifier_button = 46; */
+        if (message.type.oneofKind === "setTournamentShowQualifierButton")
+            Request_SetTournamentShowQualifierButton.internalBinaryWrite(message.type.setTournamentShowQualifierButton, writer.tag(46, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentAllowUnauthorizedView set_tournament_allow_unauthorized_view = 54; */
+        if (message.type.oneofKind === "setTournamentAllowUnauthorizedView")
+            Request_SetTournamentAllowUnauthorizedView.internalBinaryWrite(message.type.setTournamentAllowUnauthorizedView, writer.tag(54, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentScoreUpdateFrequency set_tournament_score_update_frequency = 47; */
+        if (message.type.oneofKind === "setTournamentScoreUpdateFrequency")
+            Request_SetTournamentScoreUpdateFrequency.internalBinaryWrite(message.type.setTournamentScoreUpdateFrequency, writer.tag(47, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentBannedMods set_tournament_banned_mods = 23; */
+        if (message.type.oneofKind === "setTournamentBannedMods")
+            Request_SetTournamentBannedMods.internalBinaryWrite(message.type.setTournamentBannedMods, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddTournamentTeam add_tournament_team = 24; */
+        if (message.type.oneofKind === "addTournamentTeam")
+            Request_AddTournamentTeam.internalBinaryWrite(message.type.addTournamentTeam, writer.tag(24, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentTeamName set_tournament_team_name = 25; */
+        if (message.type.oneofKind === "setTournamentTeamName")
+            Request_SetTournamentTeamName.internalBinaryWrite(message.type.setTournamentTeamName, writer.tag(25, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentTeamImage set_tournament_team_image = 26; */
+        if (message.type.oneofKind === "setTournamentTeamImage")
+            Request_SetTournamentTeamImage.internalBinaryWrite(message.type.setTournamentTeamImage, writer.tag(26, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveTournamentTeam remove_tournament_team = 27; */
+        if (message.type.oneofKind === "removeTournamentTeam")
+            Request_RemoveTournamentTeam.internalBinaryWrite(message.type.removeTournamentTeam, writer.tag(27, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddTournamentPool add_tournament_pool = 28; */
+        if (message.type.oneofKind === "addTournamentPool")
+            Request_AddTournamentPool.internalBinaryWrite(message.type.addTournamentPool, writer.tag(28, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SetTournamentPoolName set_tournament_pool_name = 29; */
+        if (message.type.oneofKind === "setTournamentPoolName")
+            Request_SetTournamentPoolName.internalBinaryWrite(message.type.setTournamentPoolName, writer.tag(29, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddTournamentPoolMap add_tournament_pool_map = 30; */
+        if (message.type.oneofKind === "addTournamentPoolMap")
+            Request_AddTournamentPoolMap.internalBinaryWrite(message.type.addTournamentPoolMap, writer.tag(30, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.UpdateTournamentPoolMap update_tournament_pool_map = 31; */
+        if (message.type.oneofKind === "updateTournamentPoolMap")
+            Request_UpdateTournamentPoolMap.internalBinaryWrite(message.type.updateTournamentPoolMap, writer.tag(31, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveTournamentPoolMap remove_tournament_pool_map = 32; */
+        if (message.type.oneofKind === "removeTournamentPoolMap")
+            Request_RemoveTournamentPoolMap.internalBinaryWrite(message.type.removeTournamentPoolMap, writer.tag(32, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemoveTournamentPool remove_tournament_pool = 33; */
+        if (message.type.oneofKind === "removeTournamentPool")
+            Request_RemoveTournamentPool.internalBinaryWrite(message.type.removeTournamentPool, writer.tag(33, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.DeleteTournament delete_tournament = 34; */
+        if (message.type.oneofKind === "deleteTournament")
+            Request_DeleteTournament.internalBinaryWrite(message.type.deleteTournament, writer.tag(34, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.AddServer add_server = 35; */
+        if (message.type.oneofKind === "addServer")
+            Request_AddServer.internalBinaryWrite(message.type.addServer, writer.tag(35, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.Connect connect = 36; */
+        if (message.type.oneofKind === "connect")
+            Request_Connect.internalBinaryWrite(message.type.connect, writer.tag(36, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.Join join = 37; */
+        if (message.type.oneofKind === "join")
+            Request_Join.internalBinaryWrite(message.type.join, writer.tag(37, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.QualifierScores qualifier_scores = 38; */
+        if (message.type.oneofKind === "qualifierScores")
+            Request_QualifierScores.internalBinaryWrite(message.type.qualifierScores, writer.tag(38, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.SubmitQualifierScore submit_qualifier_score = 39; */
+        if (message.type.oneofKind === "submitQualifierScore")
+            Request_SubmitQualifierScore.internalBinaryWrite(message.type.submitQualifierScore, writer.tag(39, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.LoadSong load_song = 40; */
+        if (message.type.oneofKind === "loadSong")
+            Request_LoadSong.internalBinaryWrite(message.type.loadSong, writer.tag(40, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.PreloadImageForStreamSync preload_image_for_stream_sync = 41; */
+        if (message.type.oneofKind === "preloadImageForStreamSync")
+            Request_PreloadImageForStreamSync.internalBinaryWrite(message.type.preloadImageForStreamSync, writer.tag(41, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.ShowModal show_modal = 42; */
+        if (message.type.oneofKind === "showModal")
+            Request_ShowModal.internalBinaryWrite(message.type.showModal, writer.tag(42, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Request.RemainingAttempts remaining_attempts = 43; */
+        if (message.type.oneofKind === "remainingAttempts")
+            Request_RemainingAttempts.internalBinaryWrite(message.type.remainingAttempts, writer.tag(43, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request
+ */
+export const Request = new Request$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_UpdateUser$Type extends MessageType<Request_UpdateUser> {
+    constructor() {
+        super("proto.packets.Request.UpdateUser", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user", kind: "message", T: () => User }
+        ]);
+    }
+    create(value?: PartialMessage<Request_UpdateUser>): Request_UpdateUser {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_UpdateUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_UpdateUser): Request_UpdateUser {
+        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.User user */ 2:
+                    message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+                    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: Request_UpdateUser, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.User user = 2; */
+        if (message.user)
+            User.internalBinaryWrite(message.user, 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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.UpdateUser
+ */
+export const Request_UpdateUser = new Request_UpdateUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_CreateMatch$Type extends MessageType<Request_CreateMatch> {
+    constructor() {
+        super("proto.packets.Request.CreateMatch", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Request_CreateMatch>): Request_CreateMatch {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_CreateMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_CreateMatch): Request_CreateMatch {
+        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.Match match */ 2:
+                    message.match = Match.internalBinaryRead(reader, reader.uint32(), options, message.match);
+                    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: Request_CreateMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.Match match = 2; */
+        if (message.match)
+            Match.internalBinaryWrite(message.match, 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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.CreateMatch
+ */
+export const Request_CreateMatch = new Request_CreateMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddUserToMatch$Type extends MessageType<Request_AddUserToMatch> {
+    constructor() {
+        super("proto.packets.Request.AddUserToMatch", [
+            { 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: "user_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddUserToMatch>): Request_AddUserToMatch {
+        const message = { tournamentId: "", matchId: "", userId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddUserToMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddUserToMatch): Request_AddUserToMatch {
+        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 user_id */ 3:
+                    message.userId = 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: Request_AddUserToMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string match_id = 2; */
+        if (message.matchId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.matchId);
+        /* string user_id = 3; */
+        if (message.userId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddUserToMatch
+ */
+export const Request_AddUserToMatch = new Request_AddUserToMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveUserFromMatch$Type extends MessageType<Request_RemoveUserFromMatch> {
+    constructor() {
+        super("proto.packets.Request.RemoveUserFromMatch", [
+            { 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: "user_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveUserFromMatch>): Request_RemoveUserFromMatch {
+        const message = { tournamentId: "", matchId: "", userId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveUserFromMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveUserFromMatch): Request_RemoveUserFromMatch {
+        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 user_id */ 3:
+                    message.userId = 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: Request_RemoveUserFromMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string match_id = 2; */
+        if (message.matchId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.matchId);
+        /* string user_id = 3; */
+        if (message.userId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveUserFromMatch
+ */
+export const Request_RemoveUserFromMatch = new Request_RemoveUserFromMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetMatchLeader$Type extends MessageType<Request_SetMatchLeader> {
+    constructor() {
+        super("proto.packets.Request.SetMatchLeader", [
+            { 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: "user_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetMatchLeader>): Request_SetMatchLeader {
+        const message = { tournamentId: "", matchId: "", userId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetMatchLeader>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetMatchLeader): Request_SetMatchLeader {
+        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 user_id */ 3:
+                    message.userId = 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: Request_SetMatchLeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string match_id = 2; */
+        if (message.matchId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.matchId);
+        /* string user_id = 3; */
+        if (message.userId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetMatchLeader
+ */
+export const Request_SetMatchLeader = new Request_SetMatchLeader$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetMatchMap$Type extends MessageType<Request_SetMatchMap> {
+    constructor() {
+        super("proto.packets.Request.SetMatchMap", [
+            { 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: "map", kind: "message", T: () => Map }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetMatchMap>): Request_SetMatchMap {
+        const message = { tournamentId: "", matchId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetMatchMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetMatchMap): Request_SetMatchMap {
+        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 /* proto.models.Map map */ 3:
+                    message.map = Map.internalBinaryRead(reader, reader.uint32(), options, message.map);
+                    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: Request_SetMatchMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string match_id = 2; */
+        if (message.matchId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.matchId);
+        /* proto.models.Map map = 3; */
+        if (message.map)
+            Map.internalBinaryWrite(message.map, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetMatchMap
+ */
+export const Request_SetMatchMap = new Request_SetMatchMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_DeleteMatch$Type extends MessageType<Request_DeleteMatch> {
+    constructor() {
+        super("proto.packets.Request.DeleteMatch", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_DeleteMatch>): Request_DeleteMatch {
+        const message = { tournamentId: "", matchId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_DeleteMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_DeleteMatch): Request_DeleteMatch {
+        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;
+                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: Request_DeleteMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string match_id = 2; */
+        if (message.matchId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.matchId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.DeleteMatch
+ */
+export const Request_DeleteMatch = new Request_DeleteMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_CreateQualifierEvent$Type extends MessageType<Request_CreateQualifierEvent> {
+    constructor() {
+        super("proto.packets.Request.CreateQualifierEvent", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "event", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Request_CreateQualifierEvent>): Request_CreateQualifierEvent {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_CreateQualifierEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_CreateQualifierEvent): Request_CreateQualifierEvent {
+        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.QualifierEvent event */ 2:
+                    message.event = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.event);
+                    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: Request_CreateQualifierEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.QualifierEvent event = 2; */
+        if (message.event)
+            QualifierEvent.internalBinaryWrite(message.event, 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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.CreateQualifierEvent
+ */
+export const Request_CreateQualifierEvent = new Request_CreateQualifierEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetQualifierName$Type extends MessageType<Request_SetQualifierName> {
+    constructor() {
+        super("proto.packets.Request.SetQualifierName", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "qualifier_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetQualifierName>): Request_SetQualifierName {
+        const message = { tournamentId: "", qualifierId: "", qualifierName: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetQualifierName>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetQualifierName): Request_SetQualifierName {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* string qualifier_name */ 3:
+                    message.qualifierName = 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: Request_SetQualifierName, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* string qualifier_name = 3; */
+        if (message.qualifierName !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.qualifierName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetQualifierName
+ */
+export const Request_SetQualifierName = new Request_SetQualifierName$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetQualifierImage$Type extends MessageType<Request_SetQualifierImage> {
+    constructor() {
+        super("proto.packets.Request.SetQualifierImage", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "qualifier_image", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetQualifierImage>): Request_SetQualifierImage {
+        const message = { tournamentId: "", qualifierId: "", qualifierImage: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetQualifierImage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetQualifierImage): Request_SetQualifierImage {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* bytes qualifier_image */ 3:
+                    message.qualifierImage = 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: Request_SetQualifierImage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* bytes qualifier_image = 3; */
+        if (message.qualifierImage.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.qualifierImage);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetQualifierImage
+ */
+export const Request_SetQualifierImage = new Request_SetQualifierImage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetQualifierInfoChannel$Type extends MessageType<Request_SetQualifierInfoChannel> {
+    constructor() {
+        super("proto.packets.Request.SetQualifierInfoChannel", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "info_channel", kind: "message", T: () => Channel }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetQualifierInfoChannel>): Request_SetQualifierInfoChannel {
+        const message = { tournamentId: "", qualifierId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetQualifierInfoChannel>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetQualifierInfoChannel): Request_SetQualifierInfoChannel {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* proto.discord.Channel info_channel */ 3:
+                    message.infoChannel = Channel.internalBinaryRead(reader, reader.uint32(), options, message.infoChannel);
+                    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: Request_SetQualifierInfoChannel, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* proto.discord.Channel info_channel = 3; */
+        if (message.infoChannel)
+            Channel.internalBinaryWrite(message.infoChannel, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetQualifierInfoChannel
+ */
+export const Request_SetQualifierInfoChannel = new Request_SetQualifierInfoChannel$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetQualifierFlags$Type extends MessageType<Request_SetQualifierFlags> {
+    constructor() {
+        super("proto.packets.Request.SetQualifierFlags", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "qualifier_flags", kind: "enum", T: () => ["proto.models.QualifierEvent.EventSettings", QualifierEvent_EventSettings] }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetQualifierFlags>): Request_SetQualifierFlags {
+        const message = { tournamentId: "", qualifierId: "", qualifierFlags: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetQualifierFlags>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetQualifierFlags): Request_SetQualifierFlags {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent.EventSettings qualifier_flags */ 3:
+                    message.qualifierFlags = 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: Request_SetQualifierFlags, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* proto.models.QualifierEvent.EventSettings qualifier_flags = 3; */
+        if (message.qualifierFlags !== 0)
+            writer.tag(3, WireType.Varint).int32(message.qualifierFlags);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetQualifierFlags
+ */
+export const Request_SetQualifierFlags = new Request_SetQualifierFlags$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetQualifierLeaderboardSort$Type extends MessageType<Request_SetQualifierLeaderboardSort> {
+    constructor() {
+        super("proto.packets.Request.SetQualifierLeaderboardSort", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "qualifier_leaderboard_sort", kind: "enum", T: () => ["proto.models.QualifierEvent.LeaderboardSort", QualifierEvent_LeaderboardSort] }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetQualifierLeaderboardSort>): Request_SetQualifierLeaderboardSort {
+        const message = { tournamentId: "", qualifierId: "", qualifierLeaderboardSort: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetQualifierLeaderboardSort>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetQualifierLeaderboardSort): Request_SetQualifierLeaderboardSort {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent.LeaderboardSort qualifier_leaderboard_sort */ 3:
+                    message.qualifierLeaderboardSort = 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: Request_SetQualifierLeaderboardSort, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* proto.models.QualifierEvent.LeaderboardSort qualifier_leaderboard_sort = 3; */
+        if (message.qualifierLeaderboardSort !== 0)
+            writer.tag(3, WireType.Varint).int32(message.qualifierLeaderboardSort);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetQualifierLeaderboardSort
+ */
+export const Request_SetQualifierLeaderboardSort = new Request_SetQualifierLeaderboardSort$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddQualifierMap$Type extends MessageType<Request_AddQualifierMap> {
+    constructor() {
+        super("proto.packets.Request.AddQualifierMap", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map", kind: "message", T: () => Map }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddQualifierMap>): Request_AddQualifierMap {
+        const message = { tournamentId: "", qualifierId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddQualifierMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddQualifierMap): Request_AddQualifierMap {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* proto.models.Map map */ 3:
+                    message.map = Map.internalBinaryRead(reader, reader.uint32(), options, message.map);
+                    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: Request_AddQualifierMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* proto.models.Map map = 3; */
+        if (message.map)
+            Map.internalBinaryWrite(message.map, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddQualifierMap
+ */
+export const Request_AddQualifierMap = new Request_AddQualifierMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_UpdateQualifierMap$Type extends MessageType<Request_UpdateQualifierMap> {
+    constructor() {
+        super("proto.packets.Request.UpdateQualifierMap", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map", kind: "message", T: () => Map }
+        ]);
+    }
+    create(value?: PartialMessage<Request_UpdateQualifierMap>): Request_UpdateQualifierMap {
+        const message = { tournamentId: "", qualifierId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_UpdateQualifierMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_UpdateQualifierMap): Request_UpdateQualifierMap {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* proto.models.Map map */ 3:
+                    message.map = Map.internalBinaryRead(reader, reader.uint32(), options, message.map);
+                    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: Request_UpdateQualifierMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* proto.models.Map map = 3; */
+        if (message.map)
+            Map.internalBinaryWrite(message.map, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.UpdateQualifierMap
+ */
+export const Request_UpdateQualifierMap = new Request_UpdateQualifierMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveQualifierMap$Type extends MessageType<Request_RemoveQualifierMap> {
+    constructor() {
+        super("proto.packets.Request.RemoveQualifierMap", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveQualifierMap>): Request_RemoveQualifierMap {
+        const message = { tournamentId: "", qualifierId: "", mapId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveQualifierMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveQualifierMap): Request_RemoveQualifierMap {
+        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 qualifier_id */ 2:
+                    message.qualifierId = reader.string();
+                    break;
+                case /* string map_id */ 3:
+                    message.mapId = 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: Request_RemoveQualifierMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        /* string map_id = 3; */
+        if (message.mapId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.mapId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveQualifierMap
+ */
+export const Request_RemoveQualifierMap = new Request_RemoveQualifierMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_DeleteQualifierEvent$Type extends MessageType<Request_DeleteQualifierEvent> {
+    constructor() {
+        super("proto.packets.Request.DeleteQualifierEvent", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_DeleteQualifierEvent>): Request_DeleteQualifierEvent {
+        const message = { tournamentId: "", qualifierId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_DeleteQualifierEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_DeleteQualifierEvent): Request_DeleteQualifierEvent {
+        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 qualifier_id */ 2:
+                    message.qualifierId = 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: Request_DeleteQualifierEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string qualifier_id = 2; */
+        if (message.qualifierId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.qualifierId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.DeleteQualifierEvent
+ */
+export const Request_DeleteQualifierEvent = new Request_DeleteQualifierEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddAuthorizedUser$Type extends MessageType<Request_AddAuthorizedUser> {
+    constructor() {
+        super("proto.packets.Request.AddAuthorizedUser", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "permission_flags", kind: "enum", T: () => ["proto.models.Permissions", Permissions] }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddAuthorizedUser>): Request_AddAuthorizedUser {
+        const message = { tournamentId: "", discordId: "", permissionFlags: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddAuthorizedUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddAuthorizedUser): Request_AddAuthorizedUser {
+        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 discord_id */ 2:
+                    message.discordId = reader.string();
+                    break;
+                case /* proto.models.Permissions permission_flags */ 3:
+                    message.permissionFlags = 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: Request_AddAuthorizedUser, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string discord_id = 2; */
+        if (message.discordId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordId);
+        /* proto.models.Permissions permission_flags = 3; */
+        if (message.permissionFlags !== 0)
+            writer.tag(3, WireType.Varint).int32(message.permissionFlags);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddAuthorizedUser
+ */
+export const Request_AddAuthorizedUser = new Request_AddAuthorizedUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddAuthorizedUserPermission$Type extends MessageType<Request_AddAuthorizedUserPermission> {
+    constructor() {
+        super("proto.packets.Request.AddAuthorizedUserPermission", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "permission", kind: "enum", T: () => ["proto.models.Permissions", Permissions] }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddAuthorizedUserPermission>): Request_AddAuthorizedUserPermission {
+        const message = { tournamentId: "", discordId: "", permission: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddAuthorizedUserPermission>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddAuthorizedUserPermission): Request_AddAuthorizedUserPermission {
+        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 discord_id */ 2:
+                    message.discordId = reader.string();
+                    break;
+                case /* proto.models.Permissions permission */ 3:
+                    message.permission = 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: Request_AddAuthorizedUserPermission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string discord_id = 2; */
+        if (message.discordId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordId);
+        /* proto.models.Permissions permission = 3; */
+        if (message.permission !== 0)
+            writer.tag(3, WireType.Varint).int32(message.permission);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddAuthorizedUserPermission
+ */
+export const Request_AddAuthorizedUserPermission = new Request_AddAuthorizedUserPermission$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveAuthorizedUserPermission$Type extends MessageType<Request_RemoveAuthorizedUserPermission> {
+    constructor() {
+        super("proto.packets.Request.RemoveAuthorizedUserPermission", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "permission", kind: "enum", T: () => ["proto.models.Permissions", Permissions] }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveAuthorizedUserPermission>): Request_RemoveAuthorizedUserPermission {
+        const message = { tournamentId: "", discordId: "", permission: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveAuthorizedUserPermission>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveAuthorizedUserPermission): Request_RemoveAuthorizedUserPermission {
+        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 discord_id */ 2:
+                    message.discordId = reader.string();
+                    break;
+                case /* proto.models.Permissions permission */ 3:
+                    message.permission = 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: Request_RemoveAuthorizedUserPermission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string discord_id = 2; */
+        if (message.discordId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordId);
+        /* proto.models.Permissions permission = 3; */
+        if (message.permission !== 0)
+            writer.tag(3, WireType.Varint).int32(message.permission);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveAuthorizedUserPermission
+ */
+export const Request_RemoveAuthorizedUserPermission = new Request_RemoveAuthorizedUserPermission$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveAuthorizedUser$Type extends MessageType<Request_RemoveAuthorizedUser> {
+    constructor() {
+        super("proto.packets.Request.RemoveAuthorizedUser", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveAuthorizedUser>): Request_RemoveAuthorizedUser {
+        const message = { tournamentId: "", discordId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveAuthorizedUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveAuthorizedUser): Request_RemoveAuthorizedUser {
+        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 discord_id */ 2:
+                    message.discordId = 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: Request_RemoveAuthorizedUser, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string discord_id = 2; */
+        if (message.discordId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveAuthorizedUser
+ */
+export const Request_RemoveAuthorizedUser = new Request_RemoveAuthorizedUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_GetAuthorizedUsers$Type extends MessageType<Request_GetAuthorizedUsers> {
+    constructor() {
+        super("proto.packets.Request.GetAuthorizedUsers", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_GetAuthorizedUsers>): Request_GetAuthorizedUsers {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_GetAuthorizedUsers>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_GetAuthorizedUsers): Request_GetAuthorizedUsers {
+        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;
+                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: Request_GetAuthorizedUsers, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.GetAuthorizedUsers
+ */
+export const Request_GetAuthorizedUsers = new Request_GetAuthorizedUsers$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_GetDiscordInfo$Type extends MessageType<Request_GetDiscordInfo> {
+    constructor() {
+        super("proto.packets.Request.GetDiscordInfo", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_GetDiscordInfo>): Request_GetDiscordInfo {
+        const message = { tournamentId: "", discordId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_GetDiscordInfo>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_GetDiscordInfo): Request_GetDiscordInfo {
+        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 discord_id */ 2:
+                    message.discordId = 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: Request_GetDiscordInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string discord_id = 2; */
+        if (message.discordId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.GetDiscordInfo
+ */
+export const Request_GetDiscordInfo = new Request_GetDiscordInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_CreateTournament$Type extends MessageType<Request_CreateTournament> {
+    constructor() {
+        super("proto.packets.Request.CreateTournament", [
+            { no: 1, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Request_CreateTournament>): Request_CreateTournament {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_CreateTournament>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_CreateTournament): Request_CreateTournament {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.Tournament tournament */ 1:
+                    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: Request_CreateTournament, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.Tournament tournament = 1; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.CreateTournament
+ */
+export const Request_CreateTournament = new Request_CreateTournament$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentName$Type extends MessageType<Request_SetTournamentName> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentName", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "tournament_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentName>): Request_SetTournamentName {
+        const message = { tournamentId: "", tournamentName: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentName>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentName): Request_SetTournamentName {
+        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 tournament_name */ 2:
+                    message.tournamentName = 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: Request_SetTournamentName, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string tournament_name = 2; */
+        if (message.tournamentName !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.tournamentName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentName
+ */
+export const Request_SetTournamentName = new Request_SetTournamentName$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentImage$Type extends MessageType<Request_SetTournamentImage> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentImage", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "tournament_image", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentImage>): Request_SetTournamentImage {
+        const message = { tournamentId: "", tournamentImage: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentImage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentImage): Request_SetTournamentImage {
+        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 /* bytes tournament_image */ 2:
+                    message.tournamentImage = 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: Request_SetTournamentImage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* bytes tournament_image = 2; */
+        if (message.tournamentImage.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.tournamentImage);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentImage
+ */
+export const Request_SetTournamentImage = new Request_SetTournamentImage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentEnableTeams$Type extends MessageType<Request_SetTournamentEnableTeams> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentEnableTeams", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "enable_teams", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentEnableTeams>): Request_SetTournamentEnableTeams {
+        const message = { tournamentId: "", enableTeams: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentEnableTeams>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentEnableTeams): Request_SetTournamentEnableTeams {
+        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 /* bool enable_teams */ 2:
+                    message.enableTeams = 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: Request_SetTournamentEnableTeams, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* bool enable_teams = 2; */
+        if (message.enableTeams !== false)
+            writer.tag(2, WireType.Varint).bool(message.enableTeams);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentEnableTeams
+ */
+export const Request_SetTournamentEnableTeams = new Request_SetTournamentEnableTeams$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentEnablePools$Type extends MessageType<Request_SetTournamentEnablePools> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentEnablePools", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "enable_pools", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentEnablePools>): Request_SetTournamentEnablePools {
+        const message = { tournamentId: "", enablePools: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentEnablePools>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentEnablePools): Request_SetTournamentEnablePools {
+        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 /* bool enable_pools */ 2:
+                    message.enablePools = 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: Request_SetTournamentEnablePools, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* bool enable_pools = 2; */
+        if (message.enablePools !== false)
+            writer.tag(2, WireType.Varint).bool(message.enablePools);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentEnablePools
+ */
+export const Request_SetTournamentEnablePools = new Request_SetTournamentEnablePools$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentShowTournamentButton$Type extends MessageType<Request_SetTournamentShowTournamentButton> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentShowTournamentButton", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "show_tournament_button", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentShowTournamentButton>): Request_SetTournamentShowTournamentButton {
+        const message = { tournamentId: "", showTournamentButton: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentShowTournamentButton>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentShowTournamentButton): Request_SetTournamentShowTournamentButton {
+        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 /* bool show_tournament_button */ 2:
+                    message.showTournamentButton = 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: Request_SetTournamentShowTournamentButton, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* bool show_tournament_button = 2; */
+        if (message.showTournamentButton !== false)
+            writer.tag(2, WireType.Varint).bool(message.showTournamentButton);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentShowTournamentButton
+ */
+export const Request_SetTournamentShowTournamentButton = new Request_SetTournamentShowTournamentButton$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentShowQualifierButton$Type extends MessageType<Request_SetTournamentShowQualifierButton> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentShowQualifierButton", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "show_qualifier_button", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentShowQualifierButton>): Request_SetTournamentShowQualifierButton {
+        const message = { tournamentId: "", showQualifierButton: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentShowQualifierButton>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentShowQualifierButton): Request_SetTournamentShowQualifierButton {
+        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 /* bool show_qualifier_button */ 2:
+                    message.showQualifierButton = 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: Request_SetTournamentShowQualifierButton, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* bool show_qualifier_button = 2; */
+        if (message.showQualifierButton !== false)
+            writer.tag(2, WireType.Varint).bool(message.showQualifierButton);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentShowQualifierButton
+ */
+export const Request_SetTournamentShowQualifierButton = new Request_SetTournamentShowQualifierButton$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentAllowUnauthorizedView$Type extends MessageType<Request_SetTournamentAllowUnauthorizedView> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentAllowUnauthorizedView", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "allow_unauthorized_view", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentAllowUnauthorizedView>): Request_SetTournamentAllowUnauthorizedView {
+        const message = { tournamentId: "", allowUnauthorizedView: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentAllowUnauthorizedView>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentAllowUnauthorizedView): Request_SetTournamentAllowUnauthorizedView {
+        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 /* bool allow_unauthorized_view */ 2:
+                    message.allowUnauthorizedView = 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: Request_SetTournamentAllowUnauthorizedView, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* bool allow_unauthorized_view = 2; */
+        if (message.allowUnauthorizedView !== false)
+            writer.tag(2, WireType.Varint).bool(message.allowUnauthorizedView);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentAllowUnauthorizedView
+ */
+export const Request_SetTournamentAllowUnauthorizedView = new Request_SetTournamentAllowUnauthorizedView$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentScoreUpdateFrequency$Type extends MessageType<Request_SetTournamentScoreUpdateFrequency> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentScoreUpdateFrequency", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "score_update_frequency", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentScoreUpdateFrequency>): Request_SetTournamentScoreUpdateFrequency {
+        const message = { tournamentId: "", scoreUpdateFrequency: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentScoreUpdateFrequency>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentScoreUpdateFrequency): Request_SetTournamentScoreUpdateFrequency {
+        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 score_update_frequency */ 2:
+                    message.scoreUpdateFrequency = 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: Request_SetTournamentScoreUpdateFrequency, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* int32 score_update_frequency = 2; */
+        if (message.scoreUpdateFrequency !== 0)
+            writer.tag(2, WireType.Varint).int32(message.scoreUpdateFrequency);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentScoreUpdateFrequency
+ */
+export const Request_SetTournamentScoreUpdateFrequency = new Request_SetTournamentScoreUpdateFrequency$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentBannedMods$Type extends MessageType<Request_SetTournamentBannedMods> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentBannedMods", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "banned_mods", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentBannedMods>): Request_SetTournamentBannedMods {
+        const message = { tournamentId: "", bannedMods: [] };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentBannedMods>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentBannedMods): Request_SetTournamentBannedMods {
+        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 /* repeated string banned_mods */ 2:
+                    message.bannedMods.push(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: Request_SetTournamentBannedMods, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* repeated string banned_mods = 2; */
+        for (let i = 0; i < message.bannedMods.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.bannedMods[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentBannedMods
+ */
+export const Request_SetTournamentBannedMods = new Request_SetTournamentBannedMods$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddTournamentTeam$Type extends MessageType<Request_AddTournamentTeam> {
+    constructor() {
+        super("proto.packets.Request.AddTournamentTeam", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "team", kind: "message", T: () => Tournament_TournamentSettings_Team }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddTournamentTeam>): Request_AddTournamentTeam {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddTournamentTeam>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddTournamentTeam): Request_AddTournamentTeam {
+        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.Tournament.TournamentSettings.Team team */ 2:
+                    message.team = Tournament_TournamentSettings_Team.internalBinaryRead(reader, reader.uint32(), options, message.team);
+                    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: Request_AddTournamentTeam, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.Tournament.TournamentSettings.Team team = 2; */
+        if (message.team)
+            Tournament_TournamentSettings_Team.internalBinaryWrite(message.team, 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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddTournamentTeam
+ */
+export const Request_AddTournamentTeam = new Request_AddTournamentTeam$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentTeamName$Type extends MessageType<Request_SetTournamentTeamName> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentTeamName", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "team_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "team_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentTeamName>): Request_SetTournamentTeamName {
+        const message = { tournamentId: "", teamId: "", teamName: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentTeamName>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentTeamName): Request_SetTournamentTeamName {
+        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 team_id */ 2:
+                    message.teamId = reader.string();
+                    break;
+                case /* string team_name */ 3:
+                    message.teamName = 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: Request_SetTournamentTeamName, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string team_id = 2; */
+        if (message.teamId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.teamId);
+        /* string team_name = 3; */
+        if (message.teamName !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.teamName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentTeamName
+ */
+export const Request_SetTournamentTeamName = new Request_SetTournamentTeamName$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentTeamImage$Type extends MessageType<Request_SetTournamentTeamImage> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentTeamImage", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "team_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "team_image", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentTeamImage>): Request_SetTournamentTeamImage {
+        const message = { tournamentId: "", teamId: "", teamImage: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentTeamImage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentTeamImage): Request_SetTournamentTeamImage {
+        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 team_id */ 2:
+                    message.teamId = reader.string();
+                    break;
+                case /* bytes team_image */ 3:
+                    message.teamImage = 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: Request_SetTournamentTeamImage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string team_id = 2; */
+        if (message.teamId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.teamId);
+        /* bytes team_image = 3; */
+        if (message.teamImage.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.teamImage);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentTeamImage
+ */
+export const Request_SetTournamentTeamImage = new Request_SetTournamentTeamImage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveTournamentTeam$Type extends MessageType<Request_RemoveTournamentTeam> {
+    constructor() {
+        super("proto.packets.Request.RemoveTournamentTeam", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "team_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveTournamentTeam>): Request_RemoveTournamentTeam {
+        const message = { tournamentId: "", teamId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveTournamentTeam>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveTournamentTeam): Request_RemoveTournamentTeam {
+        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 team_id */ 2:
+                    message.teamId = 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: Request_RemoveTournamentTeam, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string team_id = 2; */
+        if (message.teamId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.teamId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveTournamentTeam
+ */
+export const Request_RemoveTournamentTeam = new Request_RemoveTournamentTeam$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddTournamentPool$Type extends MessageType<Request_AddTournamentPool> {
+    constructor() {
+        super("proto.packets.Request.AddTournamentPool", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "pool", kind: "message", T: () => Tournament_TournamentSettings_Pool }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddTournamentPool>): Request_AddTournamentPool {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddTournamentPool>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddTournamentPool): Request_AddTournamentPool {
+        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.Tournament.TournamentSettings.Pool pool */ 2:
+                    message.pool = Tournament_TournamentSettings_Pool.internalBinaryRead(reader, reader.uint32(), options, message.pool);
+                    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: Request_AddTournamentPool, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.Tournament.TournamentSettings.Pool pool = 2; */
+        if (message.pool)
+            Tournament_TournamentSettings_Pool.internalBinaryWrite(message.pool, 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;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddTournamentPool
+ */
+export const Request_AddTournamentPool = new Request_AddTournamentPool$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SetTournamentPoolName$Type extends MessageType<Request_SetTournamentPoolName> {
+    constructor() {
+        super("proto.packets.Request.SetTournamentPoolName", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "pool_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "pool_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SetTournamentPoolName>): Request_SetTournamentPoolName {
+        const message = { tournamentId: "", poolId: "", poolName: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SetTournamentPoolName>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SetTournamentPoolName): Request_SetTournamentPoolName {
+        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 pool_id */ 2:
+                    message.poolId = reader.string();
+                    break;
+                case /* string pool_name */ 3:
+                    message.poolName = 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: Request_SetTournamentPoolName, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string pool_id = 2; */
+        if (message.poolId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.poolId);
+        /* string pool_name = 3; */
+        if (message.poolName !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.poolName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SetTournamentPoolName
+ */
+export const Request_SetTournamentPoolName = new Request_SetTournamentPoolName$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddTournamentPoolMap$Type extends MessageType<Request_AddTournamentPoolMap> {
+    constructor() {
+        super("proto.packets.Request.AddTournamentPoolMap", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "pool_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map", kind: "message", T: () => Map }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddTournamentPoolMap>): Request_AddTournamentPoolMap {
+        const message = { tournamentId: "", poolId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddTournamentPoolMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddTournamentPoolMap): Request_AddTournamentPoolMap {
+        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 pool_id */ 2:
+                    message.poolId = reader.string();
+                    break;
+                case /* proto.models.Map map */ 3:
+                    message.map = Map.internalBinaryRead(reader, reader.uint32(), options, message.map);
+                    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: Request_AddTournamentPoolMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string pool_id = 2; */
+        if (message.poolId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.poolId);
+        /* proto.models.Map map = 3; */
+        if (message.map)
+            Map.internalBinaryWrite(message.map, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddTournamentPoolMap
+ */
+export const Request_AddTournamentPoolMap = new Request_AddTournamentPoolMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_UpdateTournamentPoolMap$Type extends MessageType<Request_UpdateTournamentPoolMap> {
+    constructor() {
+        super("proto.packets.Request.UpdateTournamentPoolMap", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "pool_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map", kind: "message", T: () => Map }
+        ]);
+    }
+    create(value?: PartialMessage<Request_UpdateTournamentPoolMap>): Request_UpdateTournamentPoolMap {
+        const message = { tournamentId: "", poolId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_UpdateTournamentPoolMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_UpdateTournamentPoolMap): Request_UpdateTournamentPoolMap {
+        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 pool_id */ 2:
+                    message.poolId = reader.string();
+                    break;
+                case /* proto.models.Map map */ 3:
+                    message.map = Map.internalBinaryRead(reader, reader.uint32(), options, message.map);
+                    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: Request_UpdateTournamentPoolMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string pool_id = 2; */
+        if (message.poolId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.poolId);
+        /* proto.models.Map map = 3; */
+        if (message.map)
+            Map.internalBinaryWrite(message.map, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.UpdateTournamentPoolMap
+ */
+export const Request_UpdateTournamentPoolMap = new Request_UpdateTournamentPoolMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveTournamentPoolMap$Type extends MessageType<Request_RemoveTournamentPoolMap> {
+    constructor() {
+        super("proto.packets.Request.RemoveTournamentPoolMap", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "pool_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveTournamentPoolMap>): Request_RemoveTournamentPoolMap {
+        const message = { tournamentId: "", poolId: "", mapId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveTournamentPoolMap>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveTournamentPoolMap): Request_RemoveTournamentPoolMap {
+        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 pool_id */ 2:
+                    message.poolId = reader.string();
+                    break;
+                case /* string map_id */ 3:
+                    message.mapId = 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: Request_RemoveTournamentPoolMap, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string pool_id = 2; */
+        if (message.poolId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.poolId);
+        /* string map_id = 3; */
+        if (message.mapId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.mapId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveTournamentPoolMap
+ */
+export const Request_RemoveTournamentPoolMap = new Request_RemoveTournamentPoolMap$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemoveTournamentPool$Type extends MessageType<Request_RemoveTournamentPool> {
+    constructor() {
+        super("proto.packets.Request.RemoveTournamentPool", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "pool_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemoveTournamentPool>): Request_RemoveTournamentPool {
+        const message = { tournamentId: "", poolId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemoveTournamentPool>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemoveTournamentPool): Request_RemoveTournamentPool {
+        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 pool_id */ 2:
+                    message.poolId = 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: Request_RemoveTournamentPool, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string pool_id = 2; */
+        if (message.poolId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.poolId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemoveTournamentPool
+ */
+export const Request_RemoveTournamentPool = new Request_RemoveTournamentPool$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_DeleteTournament$Type extends MessageType<Request_DeleteTournament> {
+    constructor() {
+        super("proto.packets.Request.DeleteTournament", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_DeleteTournament>): Request_DeleteTournament {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_DeleteTournament>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_DeleteTournament): Request_DeleteTournament {
+        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;
+                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: Request_DeleteTournament, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.DeleteTournament
+ */
+export const Request_DeleteTournament = new Request_DeleteTournament$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_AddServer$Type extends MessageType<Request_AddServer> {
+    constructor() {
+        super("proto.packets.Request.AddServer", [
+            { no: 1, name: "server", kind: "message", T: () => CoreServer },
+            { no: 2, name: "auth_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_AddServer>): Request_AddServer {
+        const message = { authToken: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_AddServer>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_AddServer): Request_AddServer {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.CoreServer server */ 1:
+                    message.server = CoreServer.internalBinaryRead(reader, reader.uint32(), options, message.server);
+                    break;
+                case /* string auth_token */ 2:
+                    message.authToken = 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: Request_AddServer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.CoreServer server = 1; */
+        if (message.server)
+            CoreServer.internalBinaryWrite(message.server, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string auth_token = 2; */
+        if (message.authToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.authToken);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.AddServer
+ */
+export const Request_AddServer = new Request_AddServer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_Connect$Type extends MessageType<Request_Connect> {
+    constructor() {
+        super("proto.packets.Request.Connect", [
+            { no: 1, name: "client_version", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_Connect>): Request_Connect {
+        const message = { clientVersion: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_Connect>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_Connect): Request_Connect {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 client_version */ 1:
+                    message.clientVersion = 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: Request_Connect, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 client_version = 1; */
+        if (message.clientVersion !== 0)
+            writer.tag(1, WireType.Varint).int32(message.clientVersion);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.Connect
+ */
+export const Request_Connect = new Request_Connect$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_Join$Type extends MessageType<Request_Join> {
+    constructor() {
+        super("proto.packets.Request.Join", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "password", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_Join>): Request_Join {
+        const message = { tournamentId: "", password: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_Join>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_Join): Request_Join {
+        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 password */ 2:
+                    message.password = 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: Request_Join, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string password = 2; */
+        if (message.password !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.password);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.Join
+ */
+export const Request_Join = new Request_Join$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_QualifierScores$Type extends MessageType<Request_QualifierScores> {
+    constructor() {
+        super("proto.packets.Request.QualifierScores", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "event_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_QualifierScores>): Request_QualifierScores {
+        const message = { tournamentId: "", eventId: "", mapId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_QualifierScores>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_QualifierScores): Request_QualifierScores {
+        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 event_id */ 2:
+                    message.eventId = reader.string();
+                    break;
+                case /* string map_id */ 3:
+                    message.mapId = 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: Request_QualifierScores, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string event_id = 2; */
+        if (message.eventId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.eventId);
+        /* string map_id = 3; */
+        if (message.mapId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.mapId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.QualifierScores
+ */
+export const Request_QualifierScores = new Request_QualifierScores$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_SubmitQualifierScore$Type extends MessageType<Request_SubmitQualifierScore> {
+    constructor() {
+        super("proto.packets.Request.SubmitQualifierScore", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier_score", kind: "message", T: () => LeaderboardEntry },
+            { no: 3, name: "map", kind: "message", T: () => GameplayParameters }
+        ]);
+    }
+    create(value?: PartialMessage<Request_SubmitQualifierScore>): Request_SubmitQualifierScore {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_SubmitQualifierScore>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_SubmitQualifierScore): Request_SubmitQualifierScore {
+        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.LeaderboardEntry qualifier_score */ 2:
+                    message.qualifierScore = LeaderboardEntry.internalBinaryRead(reader, reader.uint32(), options, message.qualifierScore);
+                    break;
+                case /* proto.models.GameplayParameters map */ 3:
+                    message.map = GameplayParameters.internalBinaryRead(reader, reader.uint32(), options, message.map);
+                    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: Request_SubmitQualifierScore, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.LeaderboardEntry qualifier_score = 2; */
+        if (message.qualifierScore)
+            LeaderboardEntry.internalBinaryWrite(message.qualifierScore, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* proto.models.GameplayParameters map = 3; */
+        if (message.map)
+            GameplayParameters.internalBinaryWrite(message.map, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.SubmitQualifierScore
+ */
+export const Request_SubmitQualifierScore = new Request_SubmitQualifierScore$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_LoadSong$Type extends MessageType<Request_LoadSong> {
+    constructor() {
+        super("proto.packets.Request.LoadSong", [
+            { no: 1, name: "level_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "custom_host_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_LoadSong>): Request_LoadSong {
+        const message = { levelId: "", customHostUrl: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_LoadSong>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_LoadSong): Request_LoadSong {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string level_id */ 1:
+                    message.levelId = reader.string();
+                    break;
+                case /* string custom_host_url */ 2:
+                    message.customHostUrl = 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: Request_LoadSong, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string level_id = 1; */
+        if (message.levelId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.levelId);
+        /* string custom_host_url = 2; */
+        if (message.customHostUrl !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.customHostUrl);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.LoadSong
+ */
+export const Request_LoadSong = new Request_LoadSong$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_PreloadImageForStreamSync$Type extends MessageType<Request_PreloadImageForStreamSync> {
+    constructor() {
+        super("proto.packets.Request.PreloadImageForStreamSync", [
+            { no: 1, name: "file_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "compressed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_PreloadImageForStreamSync>): Request_PreloadImageForStreamSync {
+        const message = { fileId: "", compressed: false, data: new Uint8Array(0) };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_PreloadImageForStreamSync>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_PreloadImageForStreamSync): Request_PreloadImageForStreamSync {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string file_id */ 1:
+                    message.fileId = reader.string();
+                    break;
+                case /* bool compressed */ 2:
+                    message.compressed = reader.bool();
+                    break;
+                case /* bytes data */ 3:
+                    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: Request_PreloadImageForStreamSync, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string file_id = 1; */
+        if (message.fileId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.fileId);
+        /* bool compressed = 2; */
+        if (message.compressed !== false)
+            writer.tag(2, WireType.Varint).bool(message.compressed);
+        /* bytes data = 3; */
+        if (message.data.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.data);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.PreloadImageForStreamSync
+ */
+export const Request_PreloadImageForStreamSync = new Request_PreloadImageForStreamSync$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_ShowModal$Type extends MessageType<Request_ShowModal> {
+    constructor() {
+        super("proto.packets.Request.ShowModal", [
+            { no: 1, name: "modal_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "message_title", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "message_text", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "can_close", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "option_1", kind: "message", T: () => ModalOption },
+            { no: 6, name: "option_2", kind: "message", T: () => ModalOption }
+        ]);
+    }
+    create(value?: PartialMessage<Request_ShowModal>): Request_ShowModal {
+        const message = { modalId: "", messageTitle: "", messageText: "", canClose: false };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_ShowModal>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_ShowModal): Request_ShowModal {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string modal_id */ 1:
+                    message.modalId = reader.string();
+                    break;
+                case /* string message_title */ 2:
+                    message.messageTitle = reader.string();
+                    break;
+                case /* string message_text */ 3:
+                    message.messageText = reader.string();
+                    break;
+                case /* bool can_close */ 4:
+                    message.canClose = reader.bool();
+                    break;
+                case /* proto.models.ModalOption option_1 */ 5:
+                    message.option1 = ModalOption.internalBinaryRead(reader, reader.uint32(), options, message.option1);
+                    break;
+                case /* proto.models.ModalOption option_2 */ 6:
+                    message.option2 = ModalOption.internalBinaryRead(reader, reader.uint32(), options, message.option2);
+                    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: Request_ShowModal, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string modal_id = 1; */
+        if (message.modalId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.modalId);
+        /* string message_title = 2; */
+        if (message.messageTitle !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.messageTitle);
+        /* string message_text = 3; */
+        if (message.messageText !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.messageText);
+        /* bool can_close = 4; */
+        if (message.canClose !== false)
+            writer.tag(4, WireType.Varint).bool(message.canClose);
+        /* proto.models.ModalOption option_1 = 5; */
+        if (message.option1)
+            ModalOption.internalBinaryWrite(message.option1, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* proto.models.ModalOption option_2 = 6; */
+        if (message.option2)
+            ModalOption.internalBinaryWrite(message.option2, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.ShowModal
+ */
+export const Request_ShowModal = new Request_ShowModal$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Request_RemainingAttempts$Type extends MessageType<Request_RemainingAttempts> {
+    constructor() {
+        super("proto.packets.Request.RemainingAttempts", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "event_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "map_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Request_RemainingAttempts>): Request_RemainingAttempts {
+        const message = { tournamentId: "", eventId: "", mapId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Request_RemainingAttempts>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Request_RemainingAttempts): Request_RemainingAttempts {
+        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 event_id */ 2:
+                    message.eventId = reader.string();
+                    break;
+                case /* string map_id */ 3:
+                    message.mapId = 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: Request_RemainingAttempts, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* string event_id = 2; */
+        if (message.eventId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.eventId);
+        /* string map_id = 3; */
+        if (message.mapId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.mapId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Request.RemainingAttempts
+ */
+export const Request_RemainingAttempts = new Request_RemainingAttempts$Type();