moons-ta-client 1.0.1

package/src/models/responses.ts

@@ -0,0 +1,2184 @@
+// @generated by protobuf-ts 2.8.2
+// @generated from protobuf file "responses.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 { LeaderboardEntry } from './models.js';
+import { State } from './models.js';
+import { CoreServer } from './models.js';
+import { Tournament } from './models.js';
+import { Permissions } from './models.js';
+import { QualifierEvent } from './models.js';
+import { Match } from './models.js';
+import { User } from './models.js';
+/**
+ * ---- Responses ---- //
+ *
+ * @generated from protobuf message proto.packets.Response
+ */
+export interface Response {
+    /**
+     * @generated from protobuf field: proto.packets.Response.ResponseType type = 1;
+     */
+    type: Response_ResponseType;
+    /**
+     * @generated from protobuf field: string responding_to_packet_id = 2;
+     */
+    respondingToPacketId: string;
+    /**
+     * @generated from protobuf oneof: details
+     */
+    details: {
+        oneofKind: "updateUser";
+        /**
+         * @generated from protobuf field: proto.packets.Response.UpdateUser update_user = 3;
+         */
+        updateUser: Response_UpdateUser;
+    } | {
+        oneofKind: "createMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Response.CreateMatch create_match = 4;
+         */
+        createMatch: Response_CreateMatch;
+    } | {
+        oneofKind: "updateMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Response.UpdateMatch update_match = 5;
+         */
+        updateMatch: Response_UpdateMatch;
+    } | {
+        oneofKind: "deleteMatch";
+        /**
+         * @generated from protobuf field: proto.packets.Response.DeleteMatch delete_match = 6;
+         */
+        deleteMatch: Response_DeleteMatch;
+    } | {
+        oneofKind: "createQualifierEvent";
+        /**
+         * @generated from protobuf field: proto.packets.Response.CreateQualifierEvent create_qualifier_event = 7;
+         */
+        createQualifierEvent: Response_CreateQualifierEvent;
+    } | {
+        oneofKind: "updateQualifierEvent";
+        /**
+         * @generated from protobuf field: proto.packets.Response.UpdateQualifierEvent update_qualifier_event = 8;
+         */
+        updateQualifierEvent: Response_UpdateQualifierEvent;
+    } | {
+        oneofKind: "deleteQualifierEvent";
+        /**
+         * @generated from protobuf field: proto.packets.Response.DeleteQualifierEvent delete_qualifier_event = 9;
+         */
+        deleteQualifierEvent: Response_DeleteQualifierEvent;
+    } | {
+        oneofKind: "addAuthorizedUser";
+        /**
+         * @generated from protobuf field: proto.packets.Response.AddAuthorizedUser add_authorized_user = 21;
+         */
+        addAuthorizedUser: Response_AddAuthorizedUser;
+    } | {
+        oneofKind: "updateAuthorizedUser";
+        /**
+         * @generated from protobuf field: proto.packets.Response.UpdateAuthorizedUser update_authorized_user = 22;
+         */
+        updateAuthorizedUser: Response_UpdateAuthorizedUser;
+    } | {
+        oneofKind: "removeAuthorizedUser";
+        /**
+         * @generated from protobuf field: proto.packets.Response.RemoveAuthorizedUser remove_authorized_user = 23;
+         */
+        removeAuthorizedUser: Response_RemoveAuthorizedUser;
+    } | {
+        oneofKind: "getAuthorizedUsers";
+        /**
+         * @generated from protobuf field: proto.packets.Response.GetAuthorizedUsers get_authorized_users = 24;
+         */
+        getAuthorizedUsers: Response_GetAuthorizedUsers;
+    } | {
+        oneofKind: "getDiscordInfo";
+        /**
+         * @generated from protobuf field: proto.packets.Response.GetDiscordInfo get_discord_info = 25;
+         */
+        getDiscordInfo: Response_GetDiscordInfo;
+    } | {
+        oneofKind: "createTournament";
+        /**
+         * @generated from protobuf field: proto.packets.Response.CreateTournament create_tournament = 10;
+         */
+        createTournament: Response_CreateTournament;
+    } | {
+        oneofKind: "updateTournament";
+        /**
+         * @generated from protobuf field: proto.packets.Response.UpdateTournament update_tournament = 11;
+         */
+        updateTournament: Response_UpdateTournament;
+    } | {
+        oneofKind: "deleteTournament";
+        /**
+         * @generated from protobuf field: proto.packets.Response.DeleteTournament delete_tournament = 12;
+         */
+        deleteTournament: Response_DeleteTournament;
+    } | {
+        oneofKind: "addServer";
+        /**
+         * @generated from protobuf field: proto.packets.Response.AddServer add_server = 13;
+         */
+        addServer: Response_AddServer;
+    } | {
+        oneofKind: "connect";
+        /**
+         * @generated from protobuf field: proto.packets.Response.Connect connect = 14;
+         */
+        connect: Response_Connect;
+    } | {
+        oneofKind: "join";
+        /**
+         * @generated from protobuf field: proto.packets.Response.Join join = 15;
+         */
+        join: Response_Join;
+    } | {
+        oneofKind: "leaderboardEntries";
+        /**
+         * @generated from protobuf field: proto.packets.Response.LeaderboardEntries leaderboard_entries = 16;
+         */
+        leaderboardEntries: Response_LeaderboardEntries;
+    } | {
+        oneofKind: "loadSong";
+        /**
+         * @generated from protobuf field: proto.packets.Response.LoadSong load_song = 17;
+         */
+        loadSong: Response_LoadSong;
+    } | {
+        oneofKind: "preloadImageForStreamSync";
+        /**
+         * @generated from protobuf field: proto.packets.Response.PreloadImageForStreamSync preload_image_for_stream_sync = 18;
+         */
+        preloadImageForStreamSync: Response_PreloadImageForStreamSync;
+    } | {
+        oneofKind: "showModal";
+        /**
+         * @generated from protobuf field: proto.packets.Response.ShowModal show_modal = 19;
+         */
+        showModal: Response_ShowModal;
+    } | {
+        oneofKind: "remainingAttempts";
+        /**
+         * @generated from protobuf field: proto.packets.Response.RemainingAttempts remaining_attempts = 20;
+         */
+        remainingAttempts: Response_RemainingAttempts;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * --- State Update Responses ---//
+ *
+ * @generated from protobuf message proto.packets.Response.UpdateUser
+ */
+export interface Response_UpdateUser {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.User user = 2;
+     */
+    user?: User;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.CreateMatch
+ */
+export interface Response_CreateMatch {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.UpdateMatch
+ */
+export interface Response_UpdateMatch {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.DeleteMatch
+ */
+export interface Response_DeleteMatch {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.CreateQualifierEvent
+ */
+export interface Response_CreateQualifierEvent {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent qualifier = 2;
+     */
+    qualifier?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.UpdateQualifierEvent
+ */
+export interface Response_UpdateQualifierEvent {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent qualifier = 2;
+     */
+    qualifier?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.DeleteQualifierEvent
+ */
+export interface Response_DeleteQualifierEvent {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent qualifier = 2;
+     */
+    qualifier?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.AddAuthorizedUser
+ */
+export interface Response_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.Response.UpdateAuthorizedUser
+ */
+export interface Response_UpdateAuthorizedUser {
+    /**
+     * @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.Response.RemoveAuthorizedUser
+ */
+export interface Response_RemoveAuthorizedUser {
+    /**
+     * @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.Response.GetAuthorizedUsers
+ */
+export interface Response_GetAuthorizedUsers {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: repeated proto.packets.Response.GetAuthorizedUsers.AuthroizedUser authorized_users = 2;
+     */
+    authorizedUsers: Response_GetAuthorizedUsers_AuthroizedUser[];
+}
+/**
+ * @generated from protobuf message proto.packets.Response.GetAuthorizedUsers.AuthroizedUser
+ */
+export interface Response_GetAuthorizedUsers_AuthroizedUser {
+    /**
+     * @generated from protobuf field: string discord_id = 1;
+     */
+    discordId: string;
+    /**
+     * @generated from protobuf field: string discord_username = 2;
+     */
+    discordUsername: string;
+    /**
+     * @generated from protobuf field: string discord_avatar_url = 3;
+     */
+    discordAvatarUrl: string;
+    /**
+     * @generated from protobuf field: proto.models.Permissions permission = 4;
+     */
+    permission: Permissions;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.GetDiscordInfo
+ */
+export interface Response_GetDiscordInfo {
+    /**
+     * @generated from protobuf field: string discord_id = 1;
+     */
+    discordId: string;
+    /**
+     * @generated from protobuf field: string discord_username = 2;
+     */
+    discordUsername: string;
+    /**
+     * @generated from protobuf field: string discord_avatar_url = 3;
+     */
+    discordAvatarUrl: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.CreateTournament
+ */
+export interface Response_CreateTournament {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 2;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.UpdateTournament
+ */
+export interface Response_UpdateTournament {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 2;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.DeleteTournament
+ */
+export interface Response_DeleteTournament {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 2;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.AddServer
+ */
+export interface Response_AddServer {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.models.CoreServer server = 2;
+     */
+    server?: CoreServer;
+}
+/**
+ * -- Other Responses --/
+ *
+ * @generated from protobuf message proto.packets.Response.Connect
+ */
+export interface Response_Connect {
+    /**
+     * @generated from protobuf field: proto.models.State state = 1;
+     */
+    state?: State;
+    /**
+     * @generated from protobuf field: int32 server_version = 2;
+     */
+    serverVersion: number;
+    /**
+     * @generated from protobuf field: string message = 3;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.packets.Response.Connect.ConnectFailReason reason = 4;
+     */
+    reason: Response_Connect_ConnectFailReason;
+}
+/**
+ * @generated from protobuf enum proto.packets.Response.Connect.ConnectFailReason
+ */
+export enum Response_Connect_ConnectFailReason {
+    /**
+     * @generated from protobuf enum value: IncorrectVersion = 0;
+     */
+    IncorrectVersion = 0
+}
+/**
+ * @generated from protobuf message proto.packets.Response.Join
+ */
+export interface Response_Join {
+    /**
+     * @generated from protobuf field: proto.models.State state = 1;
+     */
+    state?: State;
+    /**
+     * @generated from protobuf field: string self_guid = 2;
+     */
+    selfGuid: string;
+    /**
+     * @generated from protobuf field: string tournament_id = 3;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: string message = 4;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: proto.packets.Response.Join.JoinFailReason reason = 5;
+     */
+    reason: Response_Join_JoinFailReason;
+}
+/**
+ * @generated from protobuf enum proto.packets.Response.Join.JoinFailReason
+ */
+export enum Response_Join_JoinFailReason {
+    /**
+     * @generated from protobuf enum value: IncorrectPassword = 0;
+     */
+    IncorrectPassword = 0
+}
+/**
+ * @generated from protobuf message proto.packets.Response.LeaderboardEntries
+ */
+export interface Response_LeaderboardEntries {
+    /**
+     * @generated from protobuf field: repeated proto.models.LeaderboardEntry scores = 1;
+     */
+    scores: LeaderboardEntry[];
+}
+/**
+ * @generated from protobuf message proto.packets.Response.LoadSong
+ */
+export interface Response_LoadSong {
+    /**
+     * @generated from protobuf field: string level_id = 1;
+     */
+    levelId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.PreloadImageForStreamSync
+ */
+export interface Response_PreloadImageForStreamSync {
+    /**
+     * @generated from protobuf field: string file_id = 1;
+     */
+    fileId: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.ShowModal
+ */
+export interface Response_ShowModal {
+    /**
+     * @generated from protobuf field: string modal_id = 1;
+     */
+    modalId: string;
+    /**
+     * @generated from protobuf field: string value = 2;
+     */
+    value: string;
+}
+/**
+ * @generated from protobuf message proto.packets.Response.RemainingAttempts
+ */
+export interface Response_RemainingAttempts {
+    /**
+     * @generated from protobuf field: int32 remaining_attempts = 1;
+     */
+    remainingAttempts: number;
+}
+/**
+ * @generated from protobuf enum proto.packets.Response.ResponseType
+ */
+export enum Response_ResponseType {
+    /**
+     * @generated from protobuf enum value: Fail = 0;
+     */
+    Fail = 0,
+    /**
+     * @generated from protobuf enum value: Success = 1;
+     */
+    Success = 1
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Response$Type extends MessageType<Response> {
+    constructor() {
+        super("proto.packets.Response", [
+            { no: 1, name: "type", kind: "enum", T: () => ["proto.packets.Response.ResponseType", Response_ResponseType] },
+            { no: 2, name: "responding_to_packet_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "update_user", kind: "message", oneof: "details", T: () => Response_UpdateUser },
+            { no: 4, name: "create_match", kind: "message", oneof: "details", T: () => Response_CreateMatch },
+            { no: 5, name: "update_match", kind: "message", oneof: "details", T: () => Response_UpdateMatch },
+            { no: 6, name: "delete_match", kind: "message", oneof: "details", T: () => Response_DeleteMatch },
+            { no: 7, name: "create_qualifier_event", kind: "message", oneof: "details", T: () => Response_CreateQualifierEvent },
+            { no: 8, name: "update_qualifier_event", kind: "message", oneof: "details", T: () => Response_UpdateQualifierEvent },
+            { no: 9, name: "delete_qualifier_event", kind: "message", oneof: "details", T: () => Response_DeleteQualifierEvent },
+            { no: 21, name: "add_authorized_user", kind: "message", oneof: "details", T: () => Response_AddAuthorizedUser },
+            { no: 22, name: "update_authorized_user", kind: "message", oneof: "details", T: () => Response_UpdateAuthorizedUser },
+            { no: 23, name: "remove_authorized_user", kind: "message", oneof: "details", T: () => Response_RemoveAuthorizedUser },
+            { no: 24, name: "get_authorized_users", kind: "message", oneof: "details", T: () => Response_GetAuthorizedUsers },
+            { no: 25, name: "get_discord_info", kind: "message", oneof: "details", T: () => Response_GetDiscordInfo },
+            { no: 10, name: "create_tournament", kind: "message", oneof: "details", T: () => Response_CreateTournament },
+            { no: 11, name: "update_tournament", kind: "message", oneof: "details", T: () => Response_UpdateTournament },
+            { no: 12, name: "delete_tournament", kind: "message", oneof: "details", T: () => Response_DeleteTournament },
+            { no: 13, name: "add_server", kind: "message", oneof: "details", T: () => Response_AddServer },
+            { no: 14, name: "connect", kind: "message", oneof: "details", T: () => Response_Connect },
+            { no: 15, name: "join", kind: "message", oneof: "details", T: () => Response_Join },
+            { no: 16, name: "leaderboard_entries", kind: "message", oneof: "details", T: () => Response_LeaderboardEntries },
+            { no: 17, name: "load_song", kind: "message", oneof: "details", T: () => Response_LoadSong },
+            { no: 18, name: "preload_image_for_stream_sync", kind: "message", oneof: "details", T: () => Response_PreloadImageForStreamSync },
+            { no: 19, name: "show_modal", kind: "message", oneof: "details", T: () => Response_ShowModal },
+            { no: 20, name: "remaining_attempts", kind: "message", oneof: "details", T: () => Response_RemainingAttempts }
+        ]);
+    }
+    create(value?: PartialMessage<Response>): Response {
+        const message = { type: 0, respondingToPacketId: "", details: { oneofKind: undefined } };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response): Response {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.packets.Response.ResponseType type */ 1:
+                    message.type = reader.int32();
+                    break;
+                case /* string responding_to_packet_id */ 2:
+                    message.respondingToPacketId = reader.string();
+                    break;
+                case /* proto.packets.Response.UpdateUser update_user */ 3:
+                    message.details = {
+                        oneofKind: "updateUser",
+                        updateUser: Response_UpdateUser.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).updateUser)
+                    };
+                    break;
+                case /* proto.packets.Response.CreateMatch create_match */ 4:
+                    message.details = {
+                        oneofKind: "createMatch",
+                        createMatch: Response_CreateMatch.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).createMatch)
+                    };
+                    break;
+                case /* proto.packets.Response.UpdateMatch update_match */ 5:
+                    message.details = {
+                        oneofKind: "updateMatch",
+                        updateMatch: Response_UpdateMatch.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).updateMatch)
+                    };
+                    break;
+                case /* proto.packets.Response.DeleteMatch delete_match */ 6:
+                    message.details = {
+                        oneofKind: "deleteMatch",
+                        deleteMatch: Response_DeleteMatch.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).deleteMatch)
+                    };
+                    break;
+                case /* proto.packets.Response.CreateQualifierEvent create_qualifier_event */ 7:
+                    message.details = {
+                        oneofKind: "createQualifierEvent",
+                        createQualifierEvent: Response_CreateQualifierEvent.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).createQualifierEvent)
+                    };
+                    break;
+                case /* proto.packets.Response.UpdateQualifierEvent update_qualifier_event */ 8:
+                    message.details = {
+                        oneofKind: "updateQualifierEvent",
+                        updateQualifierEvent: Response_UpdateQualifierEvent.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).updateQualifierEvent)
+                    };
+                    break;
+                case /* proto.packets.Response.DeleteQualifierEvent delete_qualifier_event */ 9:
+                    message.details = {
+                        oneofKind: "deleteQualifierEvent",
+                        deleteQualifierEvent: Response_DeleteQualifierEvent.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).deleteQualifierEvent)
+                    };
+                    break;
+                case /* proto.packets.Response.AddAuthorizedUser add_authorized_user */ 21:
+                    message.details = {
+                        oneofKind: "addAuthorizedUser",
+                        addAuthorizedUser: Response_AddAuthorizedUser.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).addAuthorizedUser)
+                    };
+                    break;
+                case /* proto.packets.Response.UpdateAuthorizedUser update_authorized_user */ 22:
+                    message.details = {
+                        oneofKind: "updateAuthorizedUser",
+                        updateAuthorizedUser: Response_UpdateAuthorizedUser.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).updateAuthorizedUser)
+                    };
+                    break;
+                case /* proto.packets.Response.RemoveAuthorizedUser remove_authorized_user */ 23:
+                    message.details = {
+                        oneofKind: "removeAuthorizedUser",
+                        removeAuthorizedUser: Response_RemoveAuthorizedUser.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).removeAuthorizedUser)
+                    };
+                    break;
+                case /* proto.packets.Response.GetAuthorizedUsers get_authorized_users */ 24:
+                    message.details = {
+                        oneofKind: "getAuthorizedUsers",
+                        getAuthorizedUsers: Response_GetAuthorizedUsers.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).getAuthorizedUsers)
+                    };
+                    break;
+                case /* proto.packets.Response.GetDiscordInfo get_discord_info */ 25:
+                    message.details = {
+                        oneofKind: "getDiscordInfo",
+                        getDiscordInfo: Response_GetDiscordInfo.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).getDiscordInfo)
+                    };
+                    break;
+                case /* proto.packets.Response.CreateTournament create_tournament */ 10:
+                    message.details = {
+                        oneofKind: "createTournament",
+                        createTournament: Response_CreateTournament.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).createTournament)
+                    };
+                    break;
+                case /* proto.packets.Response.UpdateTournament update_tournament */ 11:
+                    message.details = {
+                        oneofKind: "updateTournament",
+                        updateTournament: Response_UpdateTournament.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).updateTournament)
+                    };
+                    break;
+                case /* proto.packets.Response.DeleteTournament delete_tournament */ 12:
+                    message.details = {
+                        oneofKind: "deleteTournament",
+                        deleteTournament: Response_DeleteTournament.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).deleteTournament)
+                    };
+                    break;
+                case /* proto.packets.Response.AddServer add_server */ 13:
+                    message.details = {
+                        oneofKind: "addServer",
+                        addServer: Response_AddServer.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).addServer)
+                    };
+                    break;
+                case /* proto.packets.Response.Connect connect */ 14:
+                    message.details = {
+                        oneofKind: "connect",
+                        connect: Response_Connect.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).connect)
+                    };
+                    break;
+                case /* proto.packets.Response.Join join */ 15:
+                    message.details = {
+                        oneofKind: "join",
+                        join: Response_Join.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).join)
+                    };
+                    break;
+                case /* proto.packets.Response.LeaderboardEntries leaderboard_entries */ 16:
+                    message.details = {
+                        oneofKind: "leaderboardEntries",
+                        leaderboardEntries: Response_LeaderboardEntries.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).leaderboardEntries)
+                    };
+                    break;
+                case /* proto.packets.Response.LoadSong load_song */ 17:
+                    message.details = {
+                        oneofKind: "loadSong",
+                        loadSong: Response_LoadSong.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).loadSong)
+                    };
+                    break;
+                case /* proto.packets.Response.PreloadImageForStreamSync preload_image_for_stream_sync */ 18:
+                    message.details = {
+                        oneofKind: "preloadImageForStreamSync",
+                        preloadImageForStreamSync: Response_PreloadImageForStreamSync.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).preloadImageForStreamSync)
+                    };
+                    break;
+                case /* proto.packets.Response.ShowModal show_modal */ 19:
+                    message.details = {
+                        oneofKind: "showModal",
+                        showModal: Response_ShowModal.internalBinaryRead(reader, reader.uint32(), options, (message.details as any).showModal)
+                    };
+                    break;
+                case /* proto.packets.Response.RemainingAttempts remaining_attempts */ 20:
+                    message.details = {
+                        oneofKind: "remainingAttempts",
+                        remainingAttempts: Response_RemainingAttempts.internalBinaryRead(reader, reader.uint32(), options, (message.details 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: Response, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.packets.Response.ResponseType type = 1; */
+        if (message.type !== 0)
+            writer.tag(1, WireType.Varint).int32(message.type);
+        /* string responding_to_packet_id = 2; */
+        if (message.respondingToPacketId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.respondingToPacketId);
+        /* proto.packets.Response.UpdateUser update_user = 3; */
+        if (message.details.oneofKind === "updateUser")
+            Response_UpdateUser.internalBinaryWrite(message.details.updateUser, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.CreateMatch create_match = 4; */
+        if (message.details.oneofKind === "createMatch")
+            Response_CreateMatch.internalBinaryWrite(message.details.createMatch, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.UpdateMatch update_match = 5; */
+        if (message.details.oneofKind === "updateMatch")
+            Response_UpdateMatch.internalBinaryWrite(message.details.updateMatch, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.DeleteMatch delete_match = 6; */
+        if (message.details.oneofKind === "deleteMatch")
+            Response_DeleteMatch.internalBinaryWrite(message.details.deleteMatch, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.CreateQualifierEvent create_qualifier_event = 7; */
+        if (message.details.oneofKind === "createQualifierEvent")
+            Response_CreateQualifierEvent.internalBinaryWrite(message.details.createQualifierEvent, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.UpdateQualifierEvent update_qualifier_event = 8; */
+        if (message.details.oneofKind === "updateQualifierEvent")
+            Response_UpdateQualifierEvent.internalBinaryWrite(message.details.updateQualifierEvent, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.DeleteQualifierEvent delete_qualifier_event = 9; */
+        if (message.details.oneofKind === "deleteQualifierEvent")
+            Response_DeleteQualifierEvent.internalBinaryWrite(message.details.deleteQualifierEvent, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.AddAuthorizedUser add_authorized_user = 21; */
+        if (message.details.oneofKind === "addAuthorizedUser")
+            Response_AddAuthorizedUser.internalBinaryWrite(message.details.addAuthorizedUser, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.UpdateAuthorizedUser update_authorized_user = 22; */
+        if (message.details.oneofKind === "updateAuthorizedUser")
+            Response_UpdateAuthorizedUser.internalBinaryWrite(message.details.updateAuthorizedUser, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.RemoveAuthorizedUser remove_authorized_user = 23; */
+        if (message.details.oneofKind === "removeAuthorizedUser")
+            Response_RemoveAuthorizedUser.internalBinaryWrite(message.details.removeAuthorizedUser, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.GetAuthorizedUsers get_authorized_users = 24; */
+        if (message.details.oneofKind === "getAuthorizedUsers")
+            Response_GetAuthorizedUsers.internalBinaryWrite(message.details.getAuthorizedUsers, writer.tag(24, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.GetDiscordInfo get_discord_info = 25; */
+        if (message.details.oneofKind === "getDiscordInfo")
+            Response_GetDiscordInfo.internalBinaryWrite(message.details.getDiscordInfo, writer.tag(25, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.CreateTournament create_tournament = 10; */
+        if (message.details.oneofKind === "createTournament")
+            Response_CreateTournament.internalBinaryWrite(message.details.createTournament, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.UpdateTournament update_tournament = 11; */
+        if (message.details.oneofKind === "updateTournament")
+            Response_UpdateTournament.internalBinaryWrite(message.details.updateTournament, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.DeleteTournament delete_tournament = 12; */
+        if (message.details.oneofKind === "deleteTournament")
+            Response_DeleteTournament.internalBinaryWrite(message.details.deleteTournament, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.AddServer add_server = 13; */
+        if (message.details.oneofKind === "addServer")
+            Response_AddServer.internalBinaryWrite(message.details.addServer, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.Connect connect = 14; */
+        if (message.details.oneofKind === "connect")
+            Response_Connect.internalBinaryWrite(message.details.connect, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.Join join = 15; */
+        if (message.details.oneofKind === "join")
+            Response_Join.internalBinaryWrite(message.details.join, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.LeaderboardEntries leaderboard_entries = 16; */
+        if (message.details.oneofKind === "leaderboardEntries")
+            Response_LeaderboardEntries.internalBinaryWrite(message.details.leaderboardEntries, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.LoadSong load_song = 17; */
+        if (message.details.oneofKind === "loadSong")
+            Response_LoadSong.internalBinaryWrite(message.details.loadSong, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.PreloadImageForStreamSync preload_image_for_stream_sync = 18; */
+        if (message.details.oneofKind === "preloadImageForStreamSync")
+            Response_PreloadImageForStreamSync.internalBinaryWrite(message.details.preloadImageForStreamSync, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.ShowModal show_modal = 19; */
+        if (message.details.oneofKind === "showModal")
+            Response_ShowModal.internalBinaryWrite(message.details.showModal, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Response.RemainingAttempts remaining_attempts = 20; */
+        if (message.details.oneofKind === "remainingAttempts")
+            Response_RemainingAttempts.internalBinaryWrite(message.details.remainingAttempts, writer.tag(20, 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.Response
+ */
+export const Response = new Response$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_UpdateUser$Type extends MessageType<Response_UpdateUser> {
+    constructor() {
+        super("proto.packets.Response.UpdateUser", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user", kind: "message", T: () => User }
+        ]);
+    }
+    create(value?: PartialMessage<Response_UpdateUser>): Response_UpdateUser {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_UpdateUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_UpdateUser): Response_UpdateUser {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = 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: Response_UpdateUser, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* 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.Response.UpdateUser
+ */
+export const Response_UpdateUser = new Response_UpdateUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_CreateMatch$Type extends MessageType<Response_CreateMatch> {
+    constructor() {
+        super("proto.packets.Response.CreateMatch", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Response_CreateMatch>): Response_CreateMatch {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_CreateMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_CreateMatch): Response_CreateMatch {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = 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: Response_CreateMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* 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.Response.CreateMatch
+ */
+export const Response_CreateMatch = new Response_CreateMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_UpdateMatch$Type extends MessageType<Response_UpdateMatch> {
+    constructor() {
+        super("proto.packets.Response.UpdateMatch", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Response_UpdateMatch>): Response_UpdateMatch {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_UpdateMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_UpdateMatch): Response_UpdateMatch {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = 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: Response_UpdateMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* 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.Response.UpdateMatch
+ */
+export const Response_UpdateMatch = new Response_UpdateMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_DeleteMatch$Type extends MessageType<Response_DeleteMatch> {
+    constructor() {
+        super("proto.packets.Response.DeleteMatch", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Response_DeleteMatch>): Response_DeleteMatch {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_DeleteMatch>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_DeleteMatch): Response_DeleteMatch {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = 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: Response_DeleteMatch, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* 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.Response.DeleteMatch
+ */
+export const Response_DeleteMatch = new Response_DeleteMatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_CreateQualifierEvent$Type extends MessageType<Response_CreateQualifierEvent> {
+    constructor() {
+        super("proto.packets.Response.CreateQualifierEvent", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Response_CreateQualifierEvent>): Response_CreateQualifierEvent {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_CreateQualifierEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_CreateQualifierEvent): Response_CreateQualifierEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent qualifier */ 2:
+                    message.qualifier = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.qualifier);
+                    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: Response_CreateQualifierEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.QualifierEvent qualifier = 2; */
+        if (message.qualifier)
+            QualifierEvent.internalBinaryWrite(message.qualifier, 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.Response.CreateQualifierEvent
+ */
+export const Response_CreateQualifierEvent = new Response_CreateQualifierEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_UpdateQualifierEvent$Type extends MessageType<Response_UpdateQualifierEvent> {
+    constructor() {
+        super("proto.packets.Response.UpdateQualifierEvent", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Response_UpdateQualifierEvent>): Response_UpdateQualifierEvent {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_UpdateQualifierEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_UpdateQualifierEvent): Response_UpdateQualifierEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent qualifier */ 2:
+                    message.qualifier = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.qualifier);
+                    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: Response_UpdateQualifierEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.QualifierEvent qualifier = 2; */
+        if (message.qualifier)
+            QualifierEvent.internalBinaryWrite(message.qualifier, 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.Response.UpdateQualifierEvent
+ */
+export const Response_UpdateQualifierEvent = new Response_UpdateQualifierEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_DeleteQualifierEvent$Type extends MessageType<Response_DeleteQualifierEvent> {
+    constructor() {
+        super("proto.packets.Response.DeleteQualifierEvent", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "qualifier", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Response_DeleteQualifierEvent>): Response_DeleteQualifierEvent {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_DeleteQualifierEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_DeleteQualifierEvent): Response_DeleteQualifierEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent qualifier */ 2:
+                    message.qualifier = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.qualifier);
+                    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: Response_DeleteQualifierEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.QualifierEvent qualifier = 2; */
+        if (message.qualifier)
+            QualifierEvent.internalBinaryWrite(message.qualifier, 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.Response.DeleteQualifierEvent
+ */
+export const Response_DeleteQualifierEvent = new Response_DeleteQualifierEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_AddAuthorizedUser$Type extends MessageType<Response_AddAuthorizedUser> {
+    constructor() {
+        super("proto.packets.Response.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<Response_AddAuthorizedUser>): Response_AddAuthorizedUser {
+        const message = { tournamentId: "", discordId: "", permissionFlags: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_AddAuthorizedUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_AddAuthorizedUser): Response_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: Response_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.Response.AddAuthorizedUser
+ */
+export const Response_AddAuthorizedUser = new Response_AddAuthorizedUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_UpdateAuthorizedUser$Type extends MessageType<Response_UpdateAuthorizedUser> {
+    constructor() {
+        super("proto.packets.Response.UpdateAuthorizedUser", [
+            { 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<Response_UpdateAuthorizedUser>): Response_UpdateAuthorizedUser {
+        const message = { tournamentId: "", discordId: "", permissionFlags: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_UpdateAuthorizedUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_UpdateAuthorizedUser): Response_UpdateAuthorizedUser {
+        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: Response_UpdateAuthorizedUser, 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.Response.UpdateAuthorizedUser
+ */
+export const Response_UpdateAuthorizedUser = new Response_UpdateAuthorizedUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_RemoveAuthorizedUser$Type extends MessageType<Response_RemoveAuthorizedUser> {
+    constructor() {
+        super("proto.packets.Response.RemoveAuthorizedUser", [
+            { 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<Response_RemoveAuthorizedUser>): Response_RemoveAuthorizedUser {
+        const message = { tournamentId: "", discordId: "", permissionFlags: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_RemoveAuthorizedUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_RemoveAuthorizedUser): Response_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;
+                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: Response_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);
+        /* 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.Response.RemoveAuthorizedUser
+ */
+export const Response_RemoveAuthorizedUser = new Response_RemoveAuthorizedUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_GetAuthorizedUsers$Type extends MessageType<Response_GetAuthorizedUsers> {
+    constructor() {
+        super("proto.packets.Response.GetAuthorizedUsers", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "authorized_users", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Response_GetAuthorizedUsers_AuthroizedUser }
+        ]);
+    }
+    create(value?: PartialMessage<Response_GetAuthorizedUsers>): Response_GetAuthorizedUsers {
+        const message = { tournamentId: "", authorizedUsers: [] };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_GetAuthorizedUsers>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_GetAuthorizedUsers): Response_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;
+                case /* repeated proto.packets.Response.GetAuthorizedUsers.AuthroizedUser authorized_users */ 2:
+                    message.authorizedUsers.push(Response_GetAuthorizedUsers_AuthroizedUser.internalBinaryRead(reader, reader.uint32(), options));
+                    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: Response_GetAuthorizedUsers, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* repeated proto.packets.Response.GetAuthorizedUsers.AuthroizedUser authorized_users = 2; */
+        for (let i = 0; i < message.authorizedUsers.length; i++)
+            Response_GetAuthorizedUsers_AuthroizedUser.internalBinaryWrite(message.authorizedUsers[i], 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.Response.GetAuthorizedUsers
+ */
+export const Response_GetAuthorizedUsers = new Response_GetAuthorizedUsers$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_GetAuthorizedUsers_AuthroizedUser$Type extends MessageType<Response_GetAuthorizedUsers_AuthroizedUser> {
+    constructor() {
+        super("proto.packets.Response.GetAuthorizedUsers.AuthroizedUser", [
+            { no: 1, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_username", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "discord_avatar_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "permission", kind: "enum", T: () => ["proto.models.Permissions", Permissions] }
+        ]);
+    }
+    create(value?: PartialMessage<Response_GetAuthorizedUsers_AuthroizedUser>): Response_GetAuthorizedUsers_AuthroizedUser {
+        const message = { discordId: "", discordUsername: "", discordAvatarUrl: "", permission: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_GetAuthorizedUsers_AuthroizedUser>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_GetAuthorizedUsers_AuthroizedUser): Response_GetAuthorizedUsers_AuthroizedUser {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string discord_id */ 1:
+                    message.discordId = reader.string();
+                    break;
+                case /* string discord_username */ 2:
+                    message.discordUsername = reader.string();
+                    break;
+                case /* string discord_avatar_url */ 3:
+                    message.discordAvatarUrl = reader.string();
+                    break;
+                case /* proto.models.Permissions permission */ 4:
+                    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: Response_GetAuthorizedUsers_AuthroizedUser, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string discord_id = 1; */
+        if (message.discordId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.discordId);
+        /* string discord_username = 2; */
+        if (message.discordUsername !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordUsername);
+        /* string discord_avatar_url = 3; */
+        if (message.discordAvatarUrl !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.discordAvatarUrl);
+        /* proto.models.Permissions permission = 4; */
+        if (message.permission !== 0)
+            writer.tag(4, 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.Response.GetAuthorizedUsers.AuthroizedUser
+ */
+export const Response_GetAuthorizedUsers_AuthroizedUser = new Response_GetAuthorizedUsers_AuthroizedUser$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_GetDiscordInfo$Type extends MessageType<Response_GetDiscordInfo> {
+    constructor() {
+        super("proto.packets.Response.GetDiscordInfo", [
+            { no: 1, name: "discord_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "discord_username", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "discord_avatar_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Response_GetDiscordInfo>): Response_GetDiscordInfo {
+        const message = { discordId: "", discordUsername: "", discordAvatarUrl: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_GetDiscordInfo>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_GetDiscordInfo): Response_GetDiscordInfo {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string discord_id */ 1:
+                    message.discordId = reader.string();
+                    break;
+                case /* string discord_username */ 2:
+                    message.discordUsername = reader.string();
+                    break;
+                case /* string discord_avatar_url */ 3:
+                    message.discordAvatarUrl = 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: Response_GetDiscordInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string discord_id = 1; */
+        if (message.discordId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.discordId);
+        /* string discord_username = 2; */
+        if (message.discordUsername !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.discordUsername);
+        /* string discord_avatar_url = 3; */
+        if (message.discordAvatarUrl !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.discordAvatarUrl);
+        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.Response.GetDiscordInfo
+ */
+export const Response_GetDiscordInfo = new Response_GetDiscordInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_CreateTournament$Type extends MessageType<Response_CreateTournament> {
+    constructor() {
+        super("proto.packets.Response.CreateTournament", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Response_CreateTournament>): Response_CreateTournament {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_CreateTournament>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_CreateTournament): Response_CreateTournament {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.Tournament tournament */ 2:
+                    message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Response_CreateTournament, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.Tournament tournament = 2; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Response.CreateTournament
+ */
+export const Response_CreateTournament = new Response_CreateTournament$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_UpdateTournament$Type extends MessageType<Response_UpdateTournament> {
+    constructor() {
+        super("proto.packets.Response.UpdateTournament", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Response_UpdateTournament>): Response_UpdateTournament {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_UpdateTournament>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_UpdateTournament): Response_UpdateTournament {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.Tournament tournament */ 2:
+                    message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Response_UpdateTournament, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.Tournament tournament = 2; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Response.UpdateTournament
+ */
+export const Response_UpdateTournament = new Response_UpdateTournament$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_DeleteTournament$Type extends MessageType<Response_DeleteTournament> {
+    constructor() {
+        super("proto.packets.Response.DeleteTournament", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Response_DeleteTournament>): Response_DeleteTournament {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_DeleteTournament>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_DeleteTournament): Response_DeleteTournament {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.Tournament tournament */ 2:
+                    message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Response_DeleteTournament, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.Tournament tournament = 2; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Response.DeleteTournament
+ */
+export const Response_DeleteTournament = new Response_DeleteTournament$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_AddServer$Type extends MessageType<Response_AddServer> {
+    constructor() {
+        super("proto.packets.Response.AddServer", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "server", kind: "message", T: () => CoreServer }
+        ]);
+    }
+    create(value?: PartialMessage<Response_AddServer>): Response_AddServer {
+        const message = { message: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_AddServer>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_AddServer): Response_AddServer {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* proto.models.CoreServer server */ 2:
+                    message.server = CoreServer.internalBinaryRead(reader, reader.uint32(), options, message.server);
+                    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: Response_AddServer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* proto.models.CoreServer server = 2; */
+        if (message.server)
+            CoreServer.internalBinaryWrite(message.server, 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.Response.AddServer
+ */
+export const Response_AddServer = new Response_AddServer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_Connect$Type extends MessageType<Response_Connect> {
+    constructor() {
+        super("proto.packets.Response.Connect", [
+            { no: 1, name: "state", kind: "message", T: () => State },
+            { no: 2, name: "server_version", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "reason", kind: "enum", T: () => ["proto.packets.Response.Connect.ConnectFailReason", Response_Connect_ConnectFailReason] }
+        ]);
+    }
+    create(value?: PartialMessage<Response_Connect>): Response_Connect {
+        const message = { serverVersion: 0, message: "", reason: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_Connect>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_Connect): Response_Connect {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.State state */ 1:
+                    message.state = State.internalBinaryRead(reader, reader.uint32(), options, message.state);
+                    break;
+                case /* int32 server_version */ 2:
+                    message.serverVersion = reader.int32();
+                    break;
+                case /* string message */ 3:
+                    message.message = reader.string();
+                    break;
+                case /* proto.packets.Response.Connect.ConnectFailReason reason */ 4:
+                    message.reason = 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: Response_Connect, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.State state = 1; */
+        if (message.state)
+            State.internalBinaryWrite(message.state, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int32 server_version = 2; */
+        if (message.serverVersion !== 0)
+            writer.tag(2, WireType.Varint).int32(message.serverVersion);
+        /* string message = 3; */
+        if (message.message !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.message);
+        /* proto.packets.Response.Connect.ConnectFailReason reason = 4; */
+        if (message.reason !== 0)
+            writer.tag(4, WireType.Varint).int32(message.reason);
+        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.Response.Connect
+ */
+export const Response_Connect = new Response_Connect$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_Join$Type extends MessageType<Response_Join> {
+    constructor() {
+        super("proto.packets.Response.Join", [
+            { no: 1, name: "state", kind: "message", T: () => State },
+            { no: 2, name: "self_guid", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "reason", kind: "enum", T: () => ["proto.packets.Response.Join.JoinFailReason", Response_Join_JoinFailReason] }
+        ]);
+    }
+    create(value?: PartialMessage<Response_Join>): Response_Join {
+        const message = { selfGuid: "", tournamentId: "", message: "", reason: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_Join>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_Join): Response_Join {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.State state */ 1:
+                    message.state = State.internalBinaryRead(reader, reader.uint32(), options, message.state);
+                    break;
+                case /* string self_guid */ 2:
+                    message.selfGuid = reader.string();
+                    break;
+                case /* string tournament_id */ 3:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* string message */ 4:
+                    message.message = reader.string();
+                    break;
+                case /* proto.packets.Response.Join.JoinFailReason reason */ 5:
+                    message.reason = 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: Response_Join, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.State state = 1; */
+        if (message.state)
+            State.internalBinaryWrite(message.state, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string self_guid = 2; */
+        if (message.selfGuid !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.selfGuid);
+        /* string tournament_id = 3; */
+        if (message.tournamentId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.tournamentId);
+        /* string message = 4; */
+        if (message.message !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.message);
+        /* proto.packets.Response.Join.JoinFailReason reason = 5; */
+        if (message.reason !== 0)
+            writer.tag(5, WireType.Varint).int32(message.reason);
+        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.Response.Join
+ */
+export const Response_Join = new Response_Join$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_LeaderboardEntries$Type extends MessageType<Response_LeaderboardEntries> {
+    constructor() {
+        super("proto.packets.Response.LeaderboardEntries", [
+            { no: 1, name: "scores", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => LeaderboardEntry }
+        ]);
+    }
+    create(value?: PartialMessage<Response_LeaderboardEntries>): Response_LeaderboardEntries {
+        const message = { scores: [] };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_LeaderboardEntries>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_LeaderboardEntries): Response_LeaderboardEntries {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated proto.models.LeaderboardEntry scores */ 1:
+                    message.scores.push(LeaderboardEntry.internalBinaryRead(reader, reader.uint32(), options));
+                    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: Response_LeaderboardEntries, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated proto.models.LeaderboardEntry scores = 1; */
+        for (let i = 0; i < message.scores.length; i++)
+            LeaderboardEntry.internalBinaryWrite(message.scores[i], 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.Response.LeaderboardEntries
+ */
+export const Response_LeaderboardEntries = new Response_LeaderboardEntries$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_LoadSong$Type extends MessageType<Response_LoadSong> {
+    constructor() {
+        super("proto.packets.Response.LoadSong", [
+            { no: 1, name: "level_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Response_LoadSong>): Response_LoadSong {
+        const message = { levelId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_LoadSong>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_LoadSong): Response_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;
+                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: Response_LoadSong, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string level_id = 1; */
+        if (message.levelId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.levelId);
+        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.Response.LoadSong
+ */
+export const Response_LoadSong = new Response_LoadSong$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_PreloadImageForStreamSync$Type extends MessageType<Response_PreloadImageForStreamSync> {
+    constructor() {
+        super("proto.packets.Response.PreloadImageForStreamSync", [
+            { no: 1, name: "file_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Response_PreloadImageForStreamSync>): Response_PreloadImageForStreamSync {
+        const message = { fileId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_PreloadImageForStreamSync>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_PreloadImageForStreamSync): Response_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;
+                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: Response_PreloadImageForStreamSync, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string file_id = 1; */
+        if (message.fileId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.fileId);
+        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.Response.PreloadImageForStreamSync
+ */
+export const Response_PreloadImageForStreamSync = new Response_PreloadImageForStreamSync$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_ShowModal$Type extends MessageType<Response_ShowModal> {
+    constructor() {
+        super("proto.packets.Response.ShowModal", [
+            { no: 1, name: "modal_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Response_ShowModal>): Response_ShowModal {
+        const message = { modalId: "", value: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_ShowModal>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_ShowModal): Response_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 value */ 2:
+                    message.value = 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: Response_ShowModal, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string modal_id = 1; */
+        if (message.modalId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.modalId);
+        /* string value = 2; */
+        if (message.value !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.value);
+        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.Response.ShowModal
+ */
+export const Response_ShowModal = new Response_ShowModal$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Response_RemainingAttempts$Type extends MessageType<Response_RemainingAttempts> {
+    constructor() {
+        super("proto.packets.Response.RemainingAttempts", [
+            { no: 1, name: "remaining_attempts", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Response_RemainingAttempts>): Response_RemainingAttempts {
+        const message = { remainingAttempts: 0 };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Response_RemainingAttempts>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Response_RemainingAttempts): Response_RemainingAttempts {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 remaining_attempts */ 1:
+                    message.remainingAttempts = 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: Response_RemainingAttempts, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 remaining_attempts = 1; */
+        if (message.remainingAttempts !== 0)
+            writer.tag(1, WireType.Varint).int32(message.remainingAttempts);
+        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.Response.RemainingAttempts
+ */
+export const Response_RemainingAttempts = new Response_RemainingAttempts$Type();