moons-ta-client 1.0.1

package/src/models/events.ts

@@ -0,0 +1,1176 @@
+// @generated by protobuf-ts 2.8.2
+// @generated from protobuf file "events.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 { CoreServer } from './models.js';
+import { Tournament } from './models.js';
+import { QualifierEvent } from './models.js';
+import { Match } from './models.js';
+import { User } from './models.js';
+/**
+ * @generated from protobuf message proto.packets.Event
+ */
+export interface Event {
+    /**
+     * @generated from protobuf oneof: changed_object
+     */
+    changedObject: {
+        oneofKind: "userAdded";
+        /**
+         * @generated from protobuf field: proto.packets.Event.UserAdded user_added = 1;
+         */
+        userAdded: Event_UserAdded;
+    } | {
+        oneofKind: "userUpdated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.UserUpdated user_updated = 2;
+         */
+        userUpdated: Event_UserUpdated;
+    } | {
+        oneofKind: "userLeft";
+        /**
+         * @generated from protobuf field: proto.packets.Event.UserLeft user_left = 3;
+         */
+        userLeft: Event_UserLeft;
+    } | {
+        oneofKind: "matchCreated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.MatchCreated match_created = 6;
+         */
+        matchCreated: Event_MatchCreated;
+    } | {
+        oneofKind: "matchUpdated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.MatchUpdated match_updated = 7;
+         */
+        matchUpdated: Event_MatchUpdated;
+    } | {
+        oneofKind: "matchDeleted";
+        /**
+         * @generated from protobuf field: proto.packets.Event.MatchDeleted match_deleted = 8;
+         */
+        matchDeleted: Event_MatchDeleted;
+    } | {
+        oneofKind: "qualifierCreated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.QualifierCreated qualifier_created = 9;
+         */
+        qualifierCreated: Event_QualifierCreated;
+    } | {
+        oneofKind: "qualifierUpdated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.QualifierUpdated qualifier_updated = 10;
+         */
+        qualifierUpdated: Event_QualifierUpdated;
+    } | {
+        oneofKind: "qualifierDeleted";
+        /**
+         * @generated from protobuf field: proto.packets.Event.QualifierDeleted qualifier_deleted = 11;
+         */
+        qualifierDeleted: Event_QualifierDeleted;
+    } | {
+        oneofKind: "tournamentCreated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.TournamentCreated tournament_created = 12;
+         */
+        tournamentCreated: Event_TournamentCreated;
+    } | {
+        oneofKind: "tournamentUpdated";
+        /**
+         * @generated from protobuf field: proto.packets.Event.TournamentUpdated tournament_updated = 13;
+         */
+        tournamentUpdated: Event_TournamentUpdated;
+    } | {
+        oneofKind: "tournamentDeleted";
+        /**
+         * @generated from protobuf field: proto.packets.Event.TournamentDeleted tournament_deleted = 14;
+         */
+        tournamentDeleted: Event_TournamentDeleted;
+    } | {
+        oneofKind: "serverAdded";
+        /**
+         * @generated from protobuf field: proto.packets.Event.ServerAdded server_added = 15;
+         */
+        serverAdded: Event_ServerAdded;
+    } | {
+        oneofKind: "serverDeleted";
+        /**
+         * @generated from protobuf field: proto.packets.Event.ServerDeleted server_deleted = 16;
+         */
+        serverDeleted: Event_ServerDeleted;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message proto.packets.Event.UserAdded
+ */
+export interface Event_UserAdded {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.User user = 2;
+     */
+    user?: User;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.UserUpdated
+ */
+export interface Event_UserUpdated {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.User user = 2;
+     */
+    user?: User;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.UserLeft
+ */
+export interface Event_UserLeft {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.User user = 2;
+     */
+    user?: User;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.MatchCreated
+ */
+export interface Event_MatchCreated {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.MatchUpdated
+ */
+export interface Event_MatchUpdated {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.MatchDeleted
+ */
+export interface Event_MatchDeleted {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.Match match = 2;
+     */
+    match?: Match;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.QualifierCreated
+ */
+export interface Event_QualifierCreated {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent event = 2;
+     */
+    event?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.QualifierUpdated
+ */
+export interface Event_QualifierUpdated {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent event = 2;
+     */
+    event?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.QualifierDeleted
+ */
+export interface Event_QualifierDeleted {
+    /**
+     * @generated from protobuf field: string tournament_id = 1;
+     */
+    tournamentId: string;
+    /**
+     * @generated from protobuf field: proto.models.QualifierEvent event = 2;
+     */
+    event?: QualifierEvent;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.TournamentCreated
+ */
+export interface Event_TournamentCreated {
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 1;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.TournamentUpdated
+ */
+export interface Event_TournamentUpdated {
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 1;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.TournamentDeleted
+ */
+export interface Event_TournamentDeleted {
+    /**
+     * @generated from protobuf field: proto.models.Tournament tournament = 1;
+     */
+    tournament?: Tournament;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.ServerAdded
+ */
+export interface Event_ServerAdded {
+    /**
+     * @generated from protobuf field: proto.models.CoreServer server = 1;
+     */
+    server?: CoreServer;
+}
+/**
+ * @generated from protobuf message proto.packets.Event.ServerDeleted
+ */
+export interface Event_ServerDeleted {
+    /**
+     * @generated from protobuf field: proto.models.CoreServer server = 1;
+     */
+    server?: CoreServer;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Event$Type extends MessageType<Event> {
+    constructor() {
+        super("proto.packets.Event", [
+            { no: 1, name: "user_added", kind: "message", oneof: "changedObject", T: () => Event_UserAdded },
+            { no: 2, name: "user_updated", kind: "message", oneof: "changedObject", T: () => Event_UserUpdated },
+            { no: 3, name: "user_left", kind: "message", oneof: "changedObject", T: () => Event_UserLeft },
+            { no: 6, name: "match_created", kind: "message", oneof: "changedObject", T: () => Event_MatchCreated },
+            { no: 7, name: "match_updated", kind: "message", oneof: "changedObject", T: () => Event_MatchUpdated },
+            { no: 8, name: "match_deleted", kind: "message", oneof: "changedObject", T: () => Event_MatchDeleted },
+            { no: 9, name: "qualifier_created", kind: "message", oneof: "changedObject", T: () => Event_QualifierCreated },
+            { no: 10, name: "qualifier_updated", kind: "message", oneof: "changedObject", T: () => Event_QualifierUpdated },
+            { no: 11, name: "qualifier_deleted", kind: "message", oneof: "changedObject", T: () => Event_QualifierDeleted },
+            { no: 12, name: "tournament_created", kind: "message", oneof: "changedObject", T: () => Event_TournamentCreated },
+            { no: 13, name: "tournament_updated", kind: "message", oneof: "changedObject", T: () => Event_TournamentUpdated },
+            { no: 14, name: "tournament_deleted", kind: "message", oneof: "changedObject", T: () => Event_TournamentDeleted },
+            { no: 15, name: "server_added", kind: "message", oneof: "changedObject", T: () => Event_ServerAdded },
+            { no: 16, name: "server_deleted", kind: "message", oneof: "changedObject", T: () => Event_ServerDeleted }
+        ]);
+    }
+    create(value?: PartialMessage<Event>): Event {
+        const message = { changedObject: { oneofKind: undefined } };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event): Event {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.packets.Event.UserAdded user_added */ 1:
+                    message.changedObject = {
+                        oneofKind: "userAdded",
+                        userAdded: Event_UserAdded.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).userAdded)
+                    };
+                    break;
+                case /* proto.packets.Event.UserUpdated user_updated */ 2:
+                    message.changedObject = {
+                        oneofKind: "userUpdated",
+                        userUpdated: Event_UserUpdated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).userUpdated)
+                    };
+                    break;
+                case /* proto.packets.Event.UserLeft user_left */ 3:
+                    message.changedObject = {
+                        oneofKind: "userLeft",
+                        userLeft: Event_UserLeft.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).userLeft)
+                    };
+                    break;
+                case /* proto.packets.Event.MatchCreated match_created */ 6:
+                    message.changedObject = {
+                        oneofKind: "matchCreated",
+                        matchCreated: Event_MatchCreated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).matchCreated)
+                    };
+                    break;
+                case /* proto.packets.Event.MatchUpdated match_updated */ 7:
+                    message.changedObject = {
+                        oneofKind: "matchUpdated",
+                        matchUpdated: Event_MatchUpdated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).matchUpdated)
+                    };
+                    break;
+                case /* proto.packets.Event.MatchDeleted match_deleted */ 8:
+                    message.changedObject = {
+                        oneofKind: "matchDeleted",
+                        matchDeleted: Event_MatchDeleted.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).matchDeleted)
+                    };
+                    break;
+                case /* proto.packets.Event.QualifierCreated qualifier_created */ 9:
+                    message.changedObject = {
+                        oneofKind: "qualifierCreated",
+                        qualifierCreated: Event_QualifierCreated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).qualifierCreated)
+                    };
+                    break;
+                case /* proto.packets.Event.QualifierUpdated qualifier_updated */ 10:
+                    message.changedObject = {
+                        oneofKind: "qualifierUpdated",
+                        qualifierUpdated: Event_QualifierUpdated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).qualifierUpdated)
+                    };
+                    break;
+                case /* proto.packets.Event.QualifierDeleted qualifier_deleted */ 11:
+                    message.changedObject = {
+                        oneofKind: "qualifierDeleted",
+                        qualifierDeleted: Event_QualifierDeleted.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).qualifierDeleted)
+                    };
+                    break;
+                case /* proto.packets.Event.TournamentCreated tournament_created */ 12:
+                    message.changedObject = {
+                        oneofKind: "tournamentCreated",
+                        tournamentCreated: Event_TournamentCreated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).tournamentCreated)
+                    };
+                    break;
+                case /* proto.packets.Event.TournamentUpdated tournament_updated */ 13:
+                    message.changedObject = {
+                        oneofKind: "tournamentUpdated",
+                        tournamentUpdated: Event_TournamentUpdated.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).tournamentUpdated)
+                    };
+                    break;
+                case /* proto.packets.Event.TournamentDeleted tournament_deleted */ 14:
+                    message.changedObject = {
+                        oneofKind: "tournamentDeleted",
+                        tournamentDeleted: Event_TournamentDeleted.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).tournamentDeleted)
+                    };
+                    break;
+                case /* proto.packets.Event.ServerAdded server_added */ 15:
+                    message.changedObject = {
+                        oneofKind: "serverAdded",
+                        serverAdded: Event_ServerAdded.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).serverAdded)
+                    };
+                    break;
+                case /* proto.packets.Event.ServerDeleted server_deleted */ 16:
+                    message.changedObject = {
+                        oneofKind: "serverDeleted",
+                        serverDeleted: Event_ServerDeleted.internalBinaryRead(reader, reader.uint32(), options, (message.changedObject as any).serverDeleted)
+                    };
+                    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: Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.packets.Event.UserAdded user_added = 1; */
+        if (message.changedObject.oneofKind === "userAdded")
+            Event_UserAdded.internalBinaryWrite(message.changedObject.userAdded, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.UserUpdated user_updated = 2; */
+        if (message.changedObject.oneofKind === "userUpdated")
+            Event_UserUpdated.internalBinaryWrite(message.changedObject.userUpdated, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.UserLeft user_left = 3; */
+        if (message.changedObject.oneofKind === "userLeft")
+            Event_UserLeft.internalBinaryWrite(message.changedObject.userLeft, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.MatchCreated match_created = 6; */
+        if (message.changedObject.oneofKind === "matchCreated")
+            Event_MatchCreated.internalBinaryWrite(message.changedObject.matchCreated, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.MatchUpdated match_updated = 7; */
+        if (message.changedObject.oneofKind === "matchUpdated")
+            Event_MatchUpdated.internalBinaryWrite(message.changedObject.matchUpdated, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.MatchDeleted match_deleted = 8; */
+        if (message.changedObject.oneofKind === "matchDeleted")
+            Event_MatchDeleted.internalBinaryWrite(message.changedObject.matchDeleted, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.QualifierCreated qualifier_created = 9; */
+        if (message.changedObject.oneofKind === "qualifierCreated")
+            Event_QualifierCreated.internalBinaryWrite(message.changedObject.qualifierCreated, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.QualifierUpdated qualifier_updated = 10; */
+        if (message.changedObject.oneofKind === "qualifierUpdated")
+            Event_QualifierUpdated.internalBinaryWrite(message.changedObject.qualifierUpdated, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.QualifierDeleted qualifier_deleted = 11; */
+        if (message.changedObject.oneofKind === "qualifierDeleted")
+            Event_QualifierDeleted.internalBinaryWrite(message.changedObject.qualifierDeleted, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.TournamentCreated tournament_created = 12; */
+        if (message.changedObject.oneofKind === "tournamentCreated")
+            Event_TournamentCreated.internalBinaryWrite(message.changedObject.tournamentCreated, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.TournamentUpdated tournament_updated = 13; */
+        if (message.changedObject.oneofKind === "tournamentUpdated")
+            Event_TournamentUpdated.internalBinaryWrite(message.changedObject.tournamentUpdated, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.TournamentDeleted tournament_deleted = 14; */
+        if (message.changedObject.oneofKind === "tournamentDeleted")
+            Event_TournamentDeleted.internalBinaryWrite(message.changedObject.tournamentDeleted, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.ServerAdded server_added = 15; */
+        if (message.changedObject.oneofKind === "serverAdded")
+            Event_ServerAdded.internalBinaryWrite(message.changedObject.serverAdded, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
+        /* proto.packets.Event.ServerDeleted server_deleted = 16; */
+        if (message.changedObject.oneofKind === "serverDeleted")
+            Event_ServerDeleted.internalBinaryWrite(message.changedObject.serverDeleted, writer.tag(16, 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.Event
+ */
+export const Event = new Event$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_UserAdded$Type extends MessageType<Event_UserAdded> {
+    constructor() {
+        super("proto.packets.Event.UserAdded", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user", kind: "message", T: () => User }
+        ]);
+    }
+    create(value?: PartialMessage<Event_UserAdded>): Event_UserAdded {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_UserAdded>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_UserAdded): Event_UserAdded {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.User user */ 2:
+                    message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_UserAdded, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.User user = 2; */
+        if (message.user)
+            User.internalBinaryWrite(message.user, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.UserAdded
+ */
+export const Event_UserAdded = new Event_UserAdded$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_UserUpdated$Type extends MessageType<Event_UserUpdated> {
+    constructor() {
+        super("proto.packets.Event.UserUpdated", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user", kind: "message", T: () => User }
+        ]);
+    }
+    create(value?: PartialMessage<Event_UserUpdated>): Event_UserUpdated {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_UserUpdated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_UserUpdated): Event_UserUpdated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.User user */ 2:
+                    message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_UserUpdated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.User user = 2; */
+        if (message.user)
+            User.internalBinaryWrite(message.user, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.UserUpdated
+ */
+export const Event_UserUpdated = new Event_UserUpdated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_UserLeft$Type extends MessageType<Event_UserLeft> {
+    constructor() {
+        super("proto.packets.Event.UserLeft", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user", kind: "message", T: () => User }
+        ]);
+    }
+    create(value?: PartialMessage<Event_UserLeft>): Event_UserLeft {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_UserLeft>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_UserLeft): Event_UserLeft {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.User user */ 2:
+                    message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_UserLeft, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.User user = 2; */
+        if (message.user)
+            User.internalBinaryWrite(message.user, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.UserLeft
+ */
+export const Event_UserLeft = new Event_UserLeft$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_MatchCreated$Type extends MessageType<Event_MatchCreated> {
+    constructor() {
+        super("proto.packets.Event.MatchCreated", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Event_MatchCreated>): Event_MatchCreated {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_MatchCreated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_MatchCreated): Event_MatchCreated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.Match match */ 2:
+                    message.match = Match.internalBinaryRead(reader, reader.uint32(), options, message.match);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_MatchCreated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.Match match = 2; */
+        if (message.match)
+            Match.internalBinaryWrite(message.match, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.MatchCreated
+ */
+export const Event_MatchCreated = new Event_MatchCreated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_MatchUpdated$Type extends MessageType<Event_MatchUpdated> {
+    constructor() {
+        super("proto.packets.Event.MatchUpdated", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Event_MatchUpdated>): Event_MatchUpdated {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_MatchUpdated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_MatchUpdated): Event_MatchUpdated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.Match match */ 2:
+                    message.match = Match.internalBinaryRead(reader, reader.uint32(), options, message.match);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_MatchUpdated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.Match match = 2; */
+        if (message.match)
+            Match.internalBinaryWrite(message.match, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.MatchUpdated
+ */
+export const Event_MatchUpdated = new Event_MatchUpdated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_MatchDeleted$Type extends MessageType<Event_MatchDeleted> {
+    constructor() {
+        super("proto.packets.Event.MatchDeleted", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "match", kind: "message", T: () => Match }
+        ]);
+    }
+    create(value?: PartialMessage<Event_MatchDeleted>): Event_MatchDeleted {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_MatchDeleted>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_MatchDeleted): Event_MatchDeleted {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.Match match */ 2:
+                    message.match = Match.internalBinaryRead(reader, reader.uint32(), options, message.match);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_MatchDeleted, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.Match match = 2; */
+        if (message.match)
+            Match.internalBinaryWrite(message.match, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.MatchDeleted
+ */
+export const Event_MatchDeleted = new Event_MatchDeleted$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_QualifierCreated$Type extends MessageType<Event_QualifierCreated> {
+    constructor() {
+        super("proto.packets.Event.QualifierCreated", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "event", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Event_QualifierCreated>): Event_QualifierCreated {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_QualifierCreated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_QualifierCreated): Event_QualifierCreated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent event */ 2:
+                    message.event = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.event);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_QualifierCreated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.QualifierEvent event = 2; */
+        if (message.event)
+            QualifierEvent.internalBinaryWrite(message.event, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.QualifierCreated
+ */
+export const Event_QualifierCreated = new Event_QualifierCreated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_QualifierUpdated$Type extends MessageType<Event_QualifierUpdated> {
+    constructor() {
+        super("proto.packets.Event.QualifierUpdated", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "event", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Event_QualifierUpdated>): Event_QualifierUpdated {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_QualifierUpdated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_QualifierUpdated): Event_QualifierUpdated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent event */ 2:
+                    message.event = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.event);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_QualifierUpdated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.QualifierEvent event = 2; */
+        if (message.event)
+            QualifierEvent.internalBinaryWrite(message.event, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.QualifierUpdated
+ */
+export const Event_QualifierUpdated = new Event_QualifierUpdated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_QualifierDeleted$Type extends MessageType<Event_QualifierDeleted> {
+    constructor() {
+        super("proto.packets.Event.QualifierDeleted", [
+            { no: 1, name: "tournament_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "event", kind: "message", T: () => QualifierEvent }
+        ]);
+    }
+    create(value?: PartialMessage<Event_QualifierDeleted>): Event_QualifierDeleted {
+        const message = { tournamentId: "" };
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_QualifierDeleted>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_QualifierDeleted): Event_QualifierDeleted {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string tournament_id */ 1:
+                    message.tournamentId = reader.string();
+                    break;
+                case /* proto.models.QualifierEvent event */ 2:
+                    message.event = QualifierEvent.internalBinaryRead(reader, reader.uint32(), options, message.event);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_QualifierDeleted, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string tournament_id = 1; */
+        if (message.tournamentId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.tournamentId);
+        /* proto.models.QualifierEvent event = 2; */
+        if (message.event)
+            QualifierEvent.internalBinaryWrite(message.event, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.QualifierDeleted
+ */
+export const Event_QualifierDeleted = new Event_QualifierDeleted$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_TournamentCreated$Type extends MessageType<Event_TournamentCreated> {
+    constructor() {
+        super("proto.packets.Event.TournamentCreated", [
+            { no: 1, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Event_TournamentCreated>): Event_TournamentCreated {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_TournamentCreated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_TournamentCreated): Event_TournamentCreated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.Tournament tournament */ 1:
+                    message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_TournamentCreated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.Tournament tournament = 1; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.TournamentCreated
+ */
+export const Event_TournamentCreated = new Event_TournamentCreated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_TournamentUpdated$Type extends MessageType<Event_TournamentUpdated> {
+    constructor() {
+        super("proto.packets.Event.TournamentUpdated", [
+            { no: 1, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Event_TournamentUpdated>): Event_TournamentUpdated {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_TournamentUpdated>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_TournamentUpdated): Event_TournamentUpdated {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.Tournament tournament */ 1:
+                    message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_TournamentUpdated, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.Tournament tournament = 1; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.TournamentUpdated
+ */
+export const Event_TournamentUpdated = new Event_TournamentUpdated$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_TournamentDeleted$Type extends MessageType<Event_TournamentDeleted> {
+    constructor() {
+        super("proto.packets.Event.TournamentDeleted", [
+            { no: 1, name: "tournament", kind: "message", T: () => Tournament }
+        ]);
+    }
+    create(value?: PartialMessage<Event_TournamentDeleted>): Event_TournamentDeleted {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_TournamentDeleted>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_TournamentDeleted): Event_TournamentDeleted {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.Tournament tournament */ 1:
+                    message.tournament = Tournament.internalBinaryRead(reader, reader.uint32(), options, message.tournament);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Event_TournamentDeleted, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.Tournament tournament = 1; */
+        if (message.tournament)
+            Tournament.internalBinaryWrite(message.tournament, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Event.TournamentDeleted
+ */
+export const Event_TournamentDeleted = new Event_TournamentDeleted$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_ServerAdded$Type extends MessageType<Event_ServerAdded> {
+    constructor() {
+        super("proto.packets.Event.ServerAdded", [
+            { no: 1, name: "server", kind: "message", T: () => CoreServer }
+        ]);
+    }
+    create(value?: PartialMessage<Event_ServerAdded>): Event_ServerAdded {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_ServerAdded>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_ServerAdded): Event_ServerAdded {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.CoreServer server */ 1:
+                    message.server = CoreServer.internalBinaryRead(reader, reader.uint32(), options, message.server);
+                    break;
+                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: Event_ServerAdded, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.CoreServer server = 1; */
+        if (message.server)
+            CoreServer.internalBinaryWrite(message.server, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        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.Event.ServerAdded
+ */
+export const Event_ServerAdded = new Event_ServerAdded$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Event_ServerDeleted$Type extends MessageType<Event_ServerDeleted> {
+    constructor() {
+        super("proto.packets.Event.ServerDeleted", [
+            { no: 1, name: "server", kind: "message", T: () => CoreServer }
+        ]);
+    }
+    create(value?: PartialMessage<Event_ServerDeleted>): Event_ServerDeleted {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Event_ServerDeleted>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event_ServerDeleted): Event_ServerDeleted {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.models.CoreServer server */ 1:
+                    message.server = CoreServer.internalBinaryRead(reader, reader.uint32(), options, message.server);
+                    break;
+                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: Event_ServerDeleted, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* proto.models.CoreServer server = 1; */
+        if (message.server)
+            CoreServer.internalBinaryWrite(message.server, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        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.Event.ServerDeleted
+ */
+export const Event_ServerDeleted = new Event_ServerDeleted$Type();