moons-ta-client 1.2.4 → 1.3.1

package/dist/models/replay_stream.js

@@ -0,0 +1,2247 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * @generated from protobuf enum proto.replay.ReplayPlatform
+ */
+export var ReplayPlatform;
+(function (ReplayPlatform) {
+    /**
+     * @generated from protobuf enum value: REPLAY_PLATFORM_UNSPECIFIED = 0;
+     */
+    ReplayPlatform[ReplayPlatform["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: REPLAY_PLATFORM_STEAM = 1;
+     */
+    ReplayPlatform[ReplayPlatform["STEAM"] = 1] = "STEAM";
+    /**
+     * @generated from protobuf enum value: REPLAY_PLATFORM_OCULUS_PC = 2;
+     */
+    ReplayPlatform[ReplayPlatform["OCULUS_PC"] = 2] = "OCULUS_PC";
+    /**
+     * @generated from protobuf enum value: REPLAY_PLATFORM_META_QUEST = 3;
+     */
+    ReplayPlatform[ReplayPlatform["META_QUEST"] = 3] = "META_QUEST";
+    /**
+     * @generated from protobuf enum value: REPLAY_PLATFORM_DEV = 4;
+     */
+    ReplayPlatform[ReplayPlatform["DEV"] = 4] = "DEV";
+})(ReplayPlatform = ReplayPlatform || (ReplayPlatform = {}));
+/**
+ * @generated from protobuf enum proto.replay.ReplayNoteEventType
+ */
+export var ReplayNoteEventType;
+(function (ReplayNoteEventType) {
+    /**
+     * @generated from protobuf enum value: REPLAY_NOTE_EVENT_TYPE_UNSPECIFIED = 0;
+     */
+    ReplayNoteEventType[ReplayNoteEventType["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: REPLAY_NOTE_EVENT_TYPE_GOOD_CUT = 1;
+     */
+    ReplayNoteEventType[ReplayNoteEventType["GOOD_CUT"] = 1] = "GOOD_CUT";
+    /**
+     * @generated from protobuf enum value: REPLAY_NOTE_EVENT_TYPE_BAD_CUT = 2;
+     */
+    ReplayNoteEventType[ReplayNoteEventType["BAD_CUT"] = 2] = "BAD_CUT";
+    /**
+     * @generated from protobuf enum value: REPLAY_NOTE_EVENT_TYPE_MISS = 3;
+     */
+    ReplayNoteEventType[ReplayNoteEventType["MISS"] = 3] = "MISS";
+    /**
+     * @generated from protobuf enum value: REPLAY_NOTE_EVENT_TYPE_BOMB = 4;
+     */
+    ReplayNoteEventType[ReplayNoteEventType["BOMB"] = 4] = "BOMB";
+})(ReplayNoteEventType = ReplayNoteEventType || (ReplayNoteEventType = {}));
+/**
+ * @generated from protobuf enum proto.replay.ReplayCompletion
+ */
+export var ReplayCompletion;
+(function (ReplayCompletion) {
+    /**
+     * @generated from protobuf enum value: REPLAY_COMPLETION_UNSPECIFIED = 0;
+     */
+    ReplayCompletion[ReplayCompletion["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from protobuf enum value: REPLAY_COMPLETION_PASSED = 1;
+     */
+    ReplayCompletion[ReplayCompletion["PASSED"] = 1] = "PASSED";
+    /**
+     * @generated from protobuf enum value: REPLAY_COMPLETION_FAILED = 2;
+     */
+    ReplayCompletion[ReplayCompletion["FAILED"] = 2] = "FAILED";
+    /**
+     * @generated from protobuf enum value: REPLAY_COMPLETION_QUIT = 3;
+     */
+    ReplayCompletion[ReplayCompletion["QUIT"] = 3] = "QUIT";
+    /**
+     * @generated from protobuf enum value: REPLAY_COMPLETION_ABORTED = 4;
+     */
+    ReplayCompletion[ReplayCompletion["ABORTED"] = 4] = "ABORTED";
+})(ReplayCompletion = ReplayCompletion || (ReplayCompletion = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayStreamPacket$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayStreamPacket", [
+            { no: 1, name: "stream_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "connection_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "player_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "match_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "start", kind: "message", oneof: "body", T: () => ReplayStreamStart },
+            { no: 11, name: "chunk", kind: "message", oneof: "body", T: () => ReplayChunk },
+            { no: 13, name: "end", kind: "message", oneof: "body", T: () => ReplayStreamEnd }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.streamId = "";
+        message.connectionId = "";
+        message.playerId = "";
+        message.matchId = "";
+        message.body = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string stream_id */ 1:
+                    message.streamId = reader.string();
+                    break;
+                case /* string connection_id */ 2:
+                    message.connectionId = reader.string();
+                    break;
+                case /* string player_id */ 3:
+                    message.playerId = reader.string();
+                    break;
+                case /* string match_id */ 4:
+                    message.matchId = reader.string();
+                    break;
+                case /* proto.replay.ReplayStreamStart start */ 10:
+                    message.body = {
+                        oneofKind: "start",
+                        start: ReplayStreamStart.internalBinaryRead(reader, reader.uint32(), options, message.body.start)
+                    };
+                    break;
+                case /* proto.replay.ReplayChunk chunk */ 11:
+                    message.body = {
+                        oneofKind: "chunk",
+                        chunk: ReplayChunk.internalBinaryRead(reader, reader.uint32(), options, message.body.chunk)
+                    };
+                    break;
+                case /* proto.replay.ReplayStreamEnd end */ 13:
+                    message.body = {
+                        oneofKind: "end",
+                        end: ReplayStreamEnd.internalBinaryRead(reader, reader.uint32(), options, message.body.end)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string stream_id = 1; */
+        if (message.streamId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.streamId);
+        /* string connection_id = 2; */
+        if (message.connectionId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.connectionId);
+        /* string player_id = 3; */
+        if (message.playerId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.playerId);
+        /* string match_id = 4; */
+        if (message.matchId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.matchId);
+        /* proto.replay.ReplayStreamStart start = 10; */
+        if (message.body.oneofKind === "start")
+            ReplayStreamStart.internalBinaryWrite(message.body.start, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayChunk chunk = 11; */
+        if (message.body.oneofKind === "chunk")
+            ReplayChunk.internalBinaryWrite(message.body.chunk, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayStreamEnd end = 13; */
+        if (message.body.oneofKind === "end")
+            ReplayStreamEnd.internalBinaryWrite(message.body.end, writer.tag(13, 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.replay.ReplayStreamPacket
+ */
+export const ReplayStreamPacket = new ReplayStreamPacket$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayStreamStart$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayStreamStart", [
+            { no: 1, name: "protocol_version", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "player", kind: "message", T: () => PlayerIdentity },
+            { no: 3, name: "beatmap", kind: "message", T: () => BeatmapIdentity },
+            { no: 9, name: "client_start_time_unix_ms", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 10, name: "server_start_time_unix_ms", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 11, name: "game_session_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 13, name: "replay_metadata", kind: "message", T: () => StreamReplayMetadata },
+            { no: 14, name: "replay_extensions", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayExtension }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.protocolVersion = 0;
+        message.clientStartTimeUnixMs = 0n;
+        message.serverStartTimeUnixMs = 0n;
+        message.gameSessionId = "";
+        message.replayExtensions = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 protocol_version */ 1:
+                    message.protocolVersion = reader.uint32();
+                    break;
+                case /* proto.replay.PlayerIdentity player */ 2:
+                    message.player = PlayerIdentity.internalBinaryRead(reader, reader.uint32(), options, message.player);
+                    break;
+                case /* proto.replay.BeatmapIdentity beatmap */ 3:
+                    message.beatmap = BeatmapIdentity.internalBinaryRead(reader, reader.uint32(), options, message.beatmap);
+                    break;
+                case /* int64 client_start_time_unix_ms */ 9:
+                    message.clientStartTimeUnixMs = reader.int64().toBigInt();
+                    break;
+                case /* int64 server_start_time_unix_ms */ 10:
+                    message.serverStartTimeUnixMs = reader.int64().toBigInt();
+                    break;
+                case /* string game_session_id */ 11:
+                    message.gameSessionId = reader.string();
+                    break;
+                case /* proto.replay.StreamReplayMetadata replay_metadata */ 13:
+                    message.replayMetadata = StreamReplayMetadata.internalBinaryRead(reader, reader.uint32(), options, message.replayMetadata);
+                    break;
+                case /* repeated proto.replay.ReplayExtension replay_extensions */ 14:
+                    message.replayExtensions.push(ReplayExtension.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, writer, options) {
+        /* uint32 protocol_version = 1; */
+        if (message.protocolVersion !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.protocolVersion);
+        /* proto.replay.PlayerIdentity player = 2; */
+        if (message.player)
+            PlayerIdentity.internalBinaryWrite(message.player, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.BeatmapIdentity beatmap = 3; */
+        if (message.beatmap)
+            BeatmapIdentity.internalBinaryWrite(message.beatmap, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* int64 client_start_time_unix_ms = 9; */
+        if (message.clientStartTimeUnixMs !== 0n)
+            writer.tag(9, WireType.Varint).int64(message.clientStartTimeUnixMs);
+        /* int64 server_start_time_unix_ms = 10; */
+        if (message.serverStartTimeUnixMs !== 0n)
+            writer.tag(10, WireType.Varint).int64(message.serverStartTimeUnixMs);
+        /* string game_session_id = 11; */
+        if (message.gameSessionId !== "")
+            writer.tag(11, WireType.LengthDelimited).string(message.gameSessionId);
+        /* proto.replay.StreamReplayMetadata replay_metadata = 13; */
+        if (message.replayMetadata)
+            StreamReplayMetadata.internalBinaryWrite(message.replayMetadata, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayExtension replay_extensions = 14; */
+        for (let i = 0; i < message.replayExtensions.length; i++)
+            ReplayExtension.internalBinaryWrite(message.replayExtensions[i], writer.tag(14, 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.replay.ReplayStreamStart
+ */
+export const ReplayStreamStart = new ReplayStreamStart$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayExtension$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayExtension", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "version", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 3, name: "payload", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.version = 0;
+        message.payload = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* uint32 version */ 2:
+                    message.version = reader.uint32();
+                    break;
+                case /* bytes payload */ 3:
+                    message.payload = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* uint32 version = 2; */
+        if (message.version !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.version);
+        /* bytes payload = 3; */
+        if (message.payload.length)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.payload);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayExtension
+ */
+export const ReplayExtension = new ReplayExtension$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PlayerIdentity$Type extends MessageType {
+    constructor() {
+        super("proto.replay.PlayerIdentity", [
+            { no: 1, name: "player_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "platform", kind: "enum", T: () => ["proto.replay.ReplayPlatform", ReplayPlatform, "REPLAY_PLATFORM_"] },
+            { no: 3, name: "game_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "client_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.playerId = "";
+        message.platform = 0;
+        message.gameVersion = "";
+        message.clientVersion = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string player_id */ 1:
+                    message.playerId = reader.string();
+                    break;
+                case /* proto.replay.ReplayPlatform platform */ 2:
+                    message.platform = reader.int32();
+                    break;
+                case /* string game_version */ 3:
+                    message.gameVersion = reader.string();
+                    break;
+                case /* string client_version */ 4:
+                    message.clientVersion = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string player_id = 1; */
+        if (message.playerId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.playerId);
+        /* proto.replay.ReplayPlatform platform = 2; */
+        if (message.platform !== 0)
+            writer.tag(2, WireType.Varint).int32(message.platform);
+        /* string game_version = 3; */
+        if (message.gameVersion !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.gameVersion);
+        /* string client_version = 4; */
+        if (message.clientVersion !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.clientVersion);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.PlayerIdentity
+ */
+export const PlayerIdentity = new PlayerIdentity$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BeatmapIdentity$Type extends MessageType {
+    constructor() {
+        super("proto.replay.BeatmapIdentity", [
+            { no: 1, name: "map_hash", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "level_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "difficulty", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "difficulty_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "characteristic", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "modifiers", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "max_score", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.mapHash = "";
+        message.levelId = "";
+        message.difficulty = 0;
+        message.difficultyName = "";
+        message.characteristic = "";
+        message.modifiers = [];
+        message.maxScore = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string map_hash */ 1:
+                    message.mapHash = reader.string();
+                    break;
+                case /* string level_id */ 2:
+                    message.levelId = reader.string();
+                    break;
+                case /* int32 difficulty */ 3:
+                    message.difficulty = reader.int32();
+                    break;
+                case /* string difficulty_name */ 4:
+                    message.difficultyName = reader.string();
+                    break;
+                case /* string characteristic */ 5:
+                    message.characteristic = reader.string();
+                    break;
+                case /* repeated string modifiers */ 7:
+                    message.modifiers.push(reader.string());
+                    break;
+                case /* uint32 max_score */ 8:
+                    message.maxScore = reader.uint32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string map_hash = 1; */
+        if (message.mapHash !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.mapHash);
+        /* string level_id = 2; */
+        if (message.levelId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.levelId);
+        /* int32 difficulty = 3; */
+        if (message.difficulty !== 0)
+            writer.tag(3, WireType.Varint).int32(message.difficulty);
+        /* string difficulty_name = 4; */
+        if (message.difficultyName !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.difficultyName);
+        /* string characteristic = 5; */
+        if (message.characteristic !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.characteristic);
+        /* repeated string modifiers = 7; */
+        for (let i = 0; i < message.modifiers.length; i++)
+            writer.tag(7, WireType.LengthDelimited).string(message.modifiers[i]);
+        /* uint32 max_score = 8; */
+        if (message.maxScore !== 0)
+            writer.tag(8, WireType.Varint).uint32(message.maxScore);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.BeatmapIdentity
+ */
+export const BeatmapIdentity = new BeatmapIdentity$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayCursor$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayCursor", [
+            { no: 1, name: "sequence", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "song_time_ms", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "server_time_unix_ms", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "client_time_unix_ms", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.sequence = 0n;
+        message.songTimeMs = 0n;
+        message.serverTimeUnixMs = 0n;
+        message.clientTimeUnixMs = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 sequence */ 1:
+                    message.sequence = reader.uint64().toBigInt();
+                    break;
+                case /* int64 song_time_ms */ 2:
+                    message.songTimeMs = reader.int64().toBigInt();
+                    break;
+                case /* int64 server_time_unix_ms */ 3:
+                    message.serverTimeUnixMs = reader.int64().toBigInt();
+                    break;
+                case /* int64 client_time_unix_ms */ 4:
+                    message.clientTimeUnixMs = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 sequence = 1; */
+        if (message.sequence !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.sequence);
+        /* int64 song_time_ms = 2; */
+        if (message.songTimeMs !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.songTimeMs);
+        /* int64 server_time_unix_ms = 3; */
+        if (message.serverTimeUnixMs !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.serverTimeUnixMs);
+        /* int64 client_time_unix_ms = 4; */
+        if (message.clientTimeUnixMs !== 0n)
+            writer.tag(4, WireType.Varint).int64(message.clientTimeUnixMs);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayCursor
+ */
+export const ReplayCursor = new ReplayCursor$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayChunk$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayChunk", [
+            { no: 1, name: "cursor", kind: "message", T: () => ReplayCursor },
+            { no: 2, name: "events", kind: "message", T: () => StreamReplayEventBatch },
+            { no: 3, name: "cumulative_event_counts", kind: "message", T: () => ReplayEventCounts }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.replay.ReplayCursor cursor */ 1:
+                    message.cursor = ReplayCursor.internalBinaryRead(reader, reader.uint32(), options, message.cursor);
+                    break;
+                case /* proto.replay.StreamReplayEventBatch events */ 2:
+                    message.events = StreamReplayEventBatch.internalBinaryRead(reader, reader.uint32(), options, message.events);
+                    break;
+                case /* proto.replay.ReplayEventCounts cumulative_event_counts */ 3:
+                    message.cumulativeEventCounts = ReplayEventCounts.internalBinaryRead(reader, reader.uint32(), options, message.cumulativeEventCounts);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* proto.replay.ReplayCursor cursor = 1; */
+        if (message.cursor)
+            ReplayCursor.internalBinaryWrite(message.cursor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.StreamReplayEventBatch events = 2; */
+        if (message.events)
+            StreamReplayEventBatch.internalBinaryWrite(message.events, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayEventCounts cumulative_event_counts = 3; */
+        if (message.cumulativeEventCounts)
+            ReplayEventCounts.internalBinaryWrite(message.cumulativeEventCounts, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayChunk
+ */
+export const ReplayChunk = new ReplayChunk$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayStreamEnd$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayStreamEnd", [
+            { no: 1, name: "cursor", kind: "message", T: () => ReplayCursor },
+            { no: 2, name: "completion", kind: "enum", T: () => ["proto.replay.ReplayCompletion", ReplayCompletion, "REPLAY_COMPLETION_"] },
+            { no: 3, name: "score", kind: "message", T: () => ReplayScoreSummary },
+            { no: 5, name: "chunk_count", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 6, name: "cumulative_event_counts", kind: "message", T: () => ReplayEventCounts }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.completion = 0;
+        message.chunkCount = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.replay.ReplayCursor cursor */ 1:
+                    message.cursor = ReplayCursor.internalBinaryRead(reader, reader.uint32(), options, message.cursor);
+                    break;
+                case /* proto.replay.ReplayCompletion completion */ 2:
+                    message.completion = reader.int32();
+                    break;
+                case /* proto.replay.ReplayScoreSummary score */ 3:
+                    message.score = ReplayScoreSummary.internalBinaryRead(reader, reader.uint32(), options, message.score);
+                    break;
+                case /* uint64 chunk_count */ 5:
+                    message.chunkCount = reader.uint64().toBigInt();
+                    break;
+                case /* proto.replay.ReplayEventCounts cumulative_event_counts */ 6:
+                    message.cumulativeEventCounts = ReplayEventCounts.internalBinaryRead(reader, reader.uint32(), options, message.cumulativeEventCounts);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* proto.replay.ReplayCursor cursor = 1; */
+        if (message.cursor)
+            ReplayCursor.internalBinaryWrite(message.cursor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayCompletion completion = 2; */
+        if (message.completion !== 0)
+            writer.tag(2, WireType.Varint).int32(message.completion);
+        /* proto.replay.ReplayScoreSummary score = 3; */
+        if (message.score)
+            ReplayScoreSummary.internalBinaryWrite(message.score, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* uint64 chunk_count = 5; */
+        if (message.chunkCount !== 0n)
+            writer.tag(5, WireType.Varint).uint64(message.chunkCount);
+        /* proto.replay.ReplayEventCounts cumulative_event_counts = 6; */
+        if (message.cumulativeEventCounts)
+            ReplayEventCounts.internalBinaryWrite(message.cumulativeEventCounts, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayStreamEnd
+ */
+export const ReplayStreamEnd = new ReplayStreamEnd$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamReplayMetadata$Type extends MessageType {
+    constructor() {
+        super("proto.replay.StreamReplayMetadata", [
+            { no: 1, name: "replay_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "level_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "difficulty", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "characteristic", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "environment", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "modifiers", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "note_spawn_offset", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 8, name: "left_handed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 9, name: "initial_height", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 10, name: "room_rotation", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 11, name: "room_center", kind: "message", T: () => ReplayVector3 },
+            { no: 13, name: "game_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 14, name: "plugin_version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 15, name: "platform", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 16, name: "song_speed", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 17, name: "jump_distance", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 18, name: "left_saber_color", kind: "message", T: () => ReplayColor },
+            { no: 19, name: "right_saber_color", kind: "message", T: () => ReplayColor }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replayVersion = "";
+        message.levelId = "";
+        message.difficulty = 0;
+        message.characteristic = "";
+        message.environment = "";
+        message.modifiers = [];
+        message.noteSpawnOffset = 0;
+        message.leftHanded = false;
+        message.initialHeight = 0;
+        message.roomRotation = 0;
+        message.gameVersion = "";
+        message.pluginVersion = "";
+        message.platform = "";
+        message.songSpeed = 0;
+        message.jumpDistance = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string replay_version */ 1:
+                    message.replayVersion = reader.string();
+                    break;
+                case /* string level_id */ 2:
+                    message.levelId = reader.string();
+                    break;
+                case /* int32 difficulty */ 3:
+                    message.difficulty = reader.int32();
+                    break;
+                case /* string characteristic */ 4:
+                    message.characteristic = reader.string();
+                    break;
+                case /* string environment */ 5:
+                    message.environment = reader.string();
+                    break;
+                case /* repeated string modifiers */ 6:
+                    message.modifiers.push(reader.string());
+                    break;
+                case /* float note_spawn_offset */ 7:
+                    message.noteSpawnOffset = reader.float();
+                    break;
+                case /* bool left_handed */ 8:
+                    message.leftHanded = reader.bool();
+                    break;
+                case /* float initial_height */ 9:
+                    message.initialHeight = reader.float();
+                    break;
+                case /* float room_rotation */ 10:
+                    message.roomRotation = reader.float();
+                    break;
+                case /* proto.replay.ReplayVector3 room_center */ 11:
+                    message.roomCenter = ReplayVector3.internalBinaryRead(reader, reader.uint32(), options, message.roomCenter);
+                    break;
+                case /* string game_version */ 13:
+                    message.gameVersion = reader.string();
+                    break;
+                case /* string plugin_version */ 14:
+                    message.pluginVersion = reader.string();
+                    break;
+                case /* string platform */ 15:
+                    message.platform = reader.string();
+                    break;
+                case /* float song_speed */ 16:
+                    message.songSpeed = reader.float();
+                    break;
+                case /* float jump_distance */ 17:
+                    message.jumpDistance = reader.float();
+                    break;
+                case /* proto.replay.ReplayColor left_saber_color */ 18:
+                    message.leftSaberColor = ReplayColor.internalBinaryRead(reader, reader.uint32(), options, message.leftSaberColor);
+                    break;
+                case /* proto.replay.ReplayColor right_saber_color */ 19:
+                    message.rightSaberColor = ReplayColor.internalBinaryRead(reader, reader.uint32(), options, message.rightSaberColor);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string replay_version = 1; */
+        if (message.replayVersion !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replayVersion);
+        /* string level_id = 2; */
+        if (message.levelId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.levelId);
+        /* int32 difficulty = 3; */
+        if (message.difficulty !== 0)
+            writer.tag(3, WireType.Varint).int32(message.difficulty);
+        /* string characteristic = 4; */
+        if (message.characteristic !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.characteristic);
+        /* string environment = 5; */
+        if (message.environment !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.environment);
+        /* repeated string modifiers = 6; */
+        for (let i = 0; i < message.modifiers.length; i++)
+            writer.tag(6, WireType.LengthDelimited).string(message.modifiers[i]);
+        /* float note_spawn_offset = 7; */
+        if (message.noteSpawnOffset !== 0)
+            writer.tag(7, WireType.Bit32).float(message.noteSpawnOffset);
+        /* bool left_handed = 8; */
+        if (message.leftHanded !== false)
+            writer.tag(8, WireType.Varint).bool(message.leftHanded);
+        /* float initial_height = 9; */
+        if (message.initialHeight !== 0)
+            writer.tag(9, WireType.Bit32).float(message.initialHeight);
+        /* float room_rotation = 10; */
+        if (message.roomRotation !== 0)
+            writer.tag(10, WireType.Bit32).float(message.roomRotation);
+        /* proto.replay.ReplayVector3 room_center = 11; */
+        if (message.roomCenter)
+            ReplayVector3.internalBinaryWrite(message.roomCenter, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* string game_version = 13; */
+        if (message.gameVersion !== "")
+            writer.tag(13, WireType.LengthDelimited).string(message.gameVersion);
+        /* string plugin_version = 14; */
+        if (message.pluginVersion !== "")
+            writer.tag(14, WireType.LengthDelimited).string(message.pluginVersion);
+        /* string platform = 15; */
+        if (message.platform !== "")
+            writer.tag(15, WireType.LengthDelimited).string(message.platform);
+        /* float song_speed = 16; */
+        if (message.songSpeed !== 0)
+            writer.tag(16, WireType.Bit32).float(message.songSpeed);
+        /* float jump_distance = 17; */
+        if (message.jumpDistance !== 0)
+            writer.tag(17, WireType.Bit32).float(message.jumpDistance);
+        /* proto.replay.ReplayColor left_saber_color = 18; */
+        if (message.leftSaberColor)
+            ReplayColor.internalBinaryWrite(message.leftSaberColor, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayColor right_saber_color = 19; */
+        if (message.rightSaberColor)
+            ReplayColor.internalBinaryWrite(message.rightSaberColor, writer.tag(19, 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.replay.StreamReplayMetadata
+ */
+export const StreamReplayMetadata = new StreamReplayMetadata$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamReplayEventBatch$Type extends MessageType {
+    constructor() {
+        super("proto.replay.StreamReplayEventBatch", [
+            { no: 1, name: "pose_frames", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayPoseFrame },
+            { no: 2, name: "height_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayHeightEvent },
+            { no: 3, name: "note_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayNoteEvent },
+            { no: 4, name: "score_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayScoreEvent },
+            { no: 5, name: "combo_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayComboEvent },
+            { no: 6, name: "multiplier_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayMultiplierEvent },
+            { no: 7, name: "energy_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayEnergyEvent },
+            { no: 8, name: "min_time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 9, name: "max_time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 10, name: "pause_events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReplayPauseEvent }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.poseFrames = [];
+        message.heightEvents = [];
+        message.noteEvents = [];
+        message.scoreEvents = [];
+        message.comboEvents = [];
+        message.multiplierEvents = [];
+        message.energyEvents = [];
+        message.minTimeSeconds = 0;
+        message.maxTimeSeconds = 0;
+        message.pauseEvents = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated proto.replay.ReplayPoseFrame pose_frames */ 1:
+                    message.poseFrames.push(ReplayPoseFrame.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated proto.replay.ReplayHeightEvent height_events */ 2:
+                    message.heightEvents.push(ReplayHeightEvent.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated proto.replay.ReplayNoteEvent note_events */ 3:
+                    message.noteEvents.push(ReplayNoteEvent.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated proto.replay.ReplayScoreEvent score_events */ 4:
+                    message.scoreEvents.push(ReplayScoreEvent.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated proto.replay.ReplayComboEvent combo_events */ 5:
+                    message.comboEvents.push(ReplayComboEvent.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated proto.replay.ReplayMultiplierEvent multiplier_events */ 6:
+                    message.multiplierEvents.push(ReplayMultiplierEvent.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated proto.replay.ReplayEnergyEvent energy_events */ 7:
+                    message.energyEvents.push(ReplayEnergyEvent.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* float min_time_seconds */ 8:
+                    message.minTimeSeconds = reader.float();
+                    break;
+                case /* float max_time_seconds */ 9:
+                    message.maxTimeSeconds = reader.float();
+                    break;
+                case /* repeated proto.replay.ReplayPauseEvent pause_events */ 10:
+                    message.pauseEvents.push(ReplayPauseEvent.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, writer, options) {
+        /* repeated proto.replay.ReplayPoseFrame pose_frames = 1; */
+        for (let i = 0; i < message.poseFrames.length; i++)
+            ReplayPoseFrame.internalBinaryWrite(message.poseFrames[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayHeightEvent height_events = 2; */
+        for (let i = 0; i < message.heightEvents.length; i++)
+            ReplayHeightEvent.internalBinaryWrite(message.heightEvents[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayNoteEvent note_events = 3; */
+        for (let i = 0; i < message.noteEvents.length; i++)
+            ReplayNoteEvent.internalBinaryWrite(message.noteEvents[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayScoreEvent score_events = 4; */
+        for (let i = 0; i < message.scoreEvents.length; i++)
+            ReplayScoreEvent.internalBinaryWrite(message.scoreEvents[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayComboEvent combo_events = 5; */
+        for (let i = 0; i < message.comboEvents.length; i++)
+            ReplayComboEvent.internalBinaryWrite(message.comboEvents[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayMultiplierEvent multiplier_events = 6; */
+        for (let i = 0; i < message.multiplierEvents.length; i++)
+            ReplayMultiplierEvent.internalBinaryWrite(message.multiplierEvents[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* repeated proto.replay.ReplayEnergyEvent energy_events = 7; */
+        for (let i = 0; i < message.energyEvents.length; i++)
+            ReplayEnergyEvent.internalBinaryWrite(message.energyEvents[i], writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* float min_time_seconds = 8; */
+        if (message.minTimeSeconds !== 0)
+            writer.tag(8, WireType.Bit32).float(message.minTimeSeconds);
+        /* float max_time_seconds = 9; */
+        if (message.maxTimeSeconds !== 0)
+            writer.tag(9, WireType.Bit32).float(message.maxTimeSeconds);
+        /* repeated proto.replay.ReplayPauseEvent pause_events = 10; */
+        for (let i = 0; i < message.pauseEvents.length; i++)
+            ReplayPauseEvent.internalBinaryWrite(message.pauseEvents[i], writer.tag(10, 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.replay.StreamReplayEventBatch
+ */
+export const StreamReplayEventBatch = new StreamReplayEventBatch$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayEventCounts$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayEventCounts", [
+            { no: 1, name: "pose_frames", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "height_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "note_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "score_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "combo_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 6, name: "multiplier_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 7, name: "energy_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 8, name: "pause_events", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.poseFrames = 0n;
+        message.heightEvents = 0n;
+        message.noteEvents = 0n;
+        message.scoreEvents = 0n;
+        message.comboEvents = 0n;
+        message.multiplierEvents = 0n;
+        message.energyEvents = 0n;
+        message.pauseEvents = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 pose_frames */ 1:
+                    message.poseFrames = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 height_events */ 2:
+                    message.heightEvents = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 note_events */ 3:
+                    message.noteEvents = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 score_events */ 4:
+                    message.scoreEvents = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 combo_events */ 5:
+                    message.comboEvents = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 multiplier_events */ 6:
+                    message.multiplierEvents = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 energy_events */ 7:
+                    message.energyEvents = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 pause_events */ 8:
+                    message.pauseEvents = reader.uint64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 pose_frames = 1; */
+        if (message.poseFrames !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.poseFrames);
+        /* uint64 height_events = 2; */
+        if (message.heightEvents !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.heightEvents);
+        /* uint64 note_events = 3; */
+        if (message.noteEvents !== 0n)
+            writer.tag(3, WireType.Varint).uint64(message.noteEvents);
+        /* uint64 score_events = 4; */
+        if (message.scoreEvents !== 0n)
+            writer.tag(4, WireType.Varint).uint64(message.scoreEvents);
+        /* uint64 combo_events = 5; */
+        if (message.comboEvents !== 0n)
+            writer.tag(5, WireType.Varint).uint64(message.comboEvents);
+        /* uint64 multiplier_events = 6; */
+        if (message.multiplierEvents !== 0n)
+            writer.tag(6, WireType.Varint).uint64(message.multiplierEvents);
+        /* uint64 energy_events = 7; */
+        if (message.energyEvents !== 0n)
+            writer.tag(7, WireType.Varint).uint64(message.energyEvents);
+        /* uint64 pause_events = 8; */
+        if (message.pauseEvents !== 0n)
+            writer.tag(8, WireType.Varint).uint64(message.pauseEvents);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayEventCounts
+ */
+export const ReplayEventCounts = new ReplayEventCounts$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayPoseFrame$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayPoseFrame", [
+            { no: 1, name: "head", kind: "message", T: () => ReplayPose },
+            { no: 2, name: "left", kind: "message", T: () => ReplayPose },
+            { no: 3, name: "right", kind: "message", T: () => ReplayPose },
+            { no: 4, name: "fps", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 5, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.fps = 0;
+        message.timeSeconds = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.replay.ReplayPose head */ 1:
+                    message.head = ReplayPose.internalBinaryRead(reader, reader.uint32(), options, message.head);
+                    break;
+                case /* proto.replay.ReplayPose left */ 2:
+                    message.left = ReplayPose.internalBinaryRead(reader, reader.uint32(), options, message.left);
+                    break;
+                case /* proto.replay.ReplayPose right */ 3:
+                    message.right = ReplayPose.internalBinaryRead(reader, reader.uint32(), options, message.right);
+                    break;
+                case /* int32 fps */ 4:
+                    message.fps = reader.int32();
+                    break;
+                case /* float time_seconds */ 5:
+                    message.timeSeconds = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* proto.replay.ReplayPose head = 1; */
+        if (message.head)
+            ReplayPose.internalBinaryWrite(message.head, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayPose left = 2; */
+        if (message.left)
+            ReplayPose.internalBinaryWrite(message.left, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayPose right = 3; */
+        if (message.right)
+            ReplayPose.internalBinaryWrite(message.right, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* int32 fps = 4; */
+        if (message.fps !== 0)
+            writer.tag(4, WireType.Varint).int32(message.fps);
+        /* float time_seconds = 5; */
+        if (message.timeSeconds !== 0)
+            writer.tag(5, WireType.Bit32).float(message.timeSeconds);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayPoseFrame
+ */
+export const ReplayPoseFrame = new ReplayPoseFrame$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayPose$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayPose", [
+            { no: 1, name: "position", kind: "message", T: () => ReplayVector3 },
+            { no: 2, name: "rotation", kind: "message", T: () => ReplayQuaternion }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.replay.ReplayVector3 position */ 1:
+                    message.position = ReplayVector3.internalBinaryRead(reader, reader.uint32(), options, message.position);
+                    break;
+                case /* proto.replay.ReplayQuaternion rotation */ 2:
+                    message.rotation = ReplayQuaternion.internalBinaryRead(reader, reader.uint32(), options, message.rotation);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* proto.replay.ReplayVector3 position = 1; */
+        if (message.position)
+            ReplayVector3.internalBinaryWrite(message.position, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayQuaternion rotation = 2; */
+        if (message.rotation)
+            ReplayQuaternion.internalBinaryWrite(message.rotation, 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.replay.ReplayPose
+ */
+export const ReplayPose = new ReplayPose$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayVector3$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayVector3", [
+            { no: 1, name: "x", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "y", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "z", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.x = 0;
+        message.y = 0;
+        message.z = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float x */ 1:
+                    message.x = reader.float();
+                    break;
+                case /* float y */ 2:
+                    message.y = reader.float();
+                    break;
+                case /* float z */ 3:
+                    message.z = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* float x = 1; */
+        if (message.x !== 0)
+            writer.tag(1, WireType.Bit32).float(message.x);
+        /* float y = 2; */
+        if (message.y !== 0)
+            writer.tag(2, WireType.Bit32).float(message.y);
+        /* float z = 3; */
+        if (message.z !== 0)
+            writer.tag(3, WireType.Bit32).float(message.z);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayVector3
+ */
+export const ReplayVector3 = new ReplayVector3$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayQuaternion$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayQuaternion", [
+            { no: 1, name: "x", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "y", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "z", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 4, name: "w", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.x = 0;
+        message.y = 0;
+        message.z = 0;
+        message.w = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float x */ 1:
+                    message.x = reader.float();
+                    break;
+                case /* float y */ 2:
+                    message.y = reader.float();
+                    break;
+                case /* float z */ 3:
+                    message.z = reader.float();
+                    break;
+                case /* float w */ 4:
+                    message.w = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* float x = 1; */
+        if (message.x !== 0)
+            writer.tag(1, WireType.Bit32).float(message.x);
+        /* float y = 2; */
+        if (message.y !== 0)
+            writer.tag(2, WireType.Bit32).float(message.y);
+        /* float z = 3; */
+        if (message.z !== 0)
+            writer.tag(3, WireType.Bit32).float(message.z);
+        /* float w = 4; */
+        if (message.w !== 0)
+            writer.tag(4, WireType.Bit32).float(message.w);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayQuaternion
+ */
+export const ReplayQuaternion = new ReplayQuaternion$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayColor$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayColor", [
+            { no: 1, name: "r", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "g", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "b", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 4, name: "a", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.r = 0;
+        message.g = 0;
+        message.b = 0;
+        message.a = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float r */ 1:
+                    message.r = reader.float();
+                    break;
+                case /* float g */ 2:
+                    message.g = reader.float();
+                    break;
+                case /* float b */ 3:
+                    message.b = reader.float();
+                    break;
+                case /* float a */ 4:
+                    message.a = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* float r = 1; */
+        if (message.r !== 0)
+            writer.tag(1, WireType.Bit32).float(message.r);
+        /* float g = 2; */
+        if (message.g !== 0)
+            writer.tag(2, WireType.Bit32).float(message.g);
+        /* float b = 3; */
+        if (message.b !== 0)
+            writer.tag(3, WireType.Bit32).float(message.b);
+        /* float a = 4; */
+        if (message.a !== 0)
+            writer.tag(4, WireType.Bit32).float(message.a);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayColor
+ */
+export const ReplayColor = new ReplayColor$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayHeightEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayHeightEvent", [
+            { no: 1, name: "height", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.height = 0;
+        message.timeSeconds = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float height */ 1:
+                    message.height = reader.float();
+                    break;
+                case /* float time_seconds */ 2:
+                    message.timeSeconds = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* float height = 1; */
+        if (message.height !== 0)
+            writer.tag(1, WireType.Bit32).float(message.height);
+        /* float time_seconds = 2; */
+        if (message.timeSeconds !== 0)
+            writer.tag(2, WireType.Bit32).float(message.timeSeconds);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayHeightEvent
+ */
+export const ReplayHeightEvent = new ReplayHeightEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayScoreEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayScoreEvent", [
+            { no: 1, name: "score", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "immediate_max_possible_score", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.score = 0;
+        message.timeSeconds = 0;
+        message.immediateMaxPossibleScore = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 score */ 1:
+                    message.score = reader.int32();
+                    break;
+                case /* float time_seconds */ 2:
+                    message.timeSeconds = reader.float();
+                    break;
+                case /* int32 immediate_max_possible_score */ 3:
+                    message.immediateMaxPossibleScore = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int32 score = 1; */
+        if (message.score !== 0)
+            writer.tag(1, WireType.Varint).int32(message.score);
+        /* float time_seconds = 2; */
+        if (message.timeSeconds !== 0)
+            writer.tag(2, WireType.Bit32).float(message.timeSeconds);
+        /* int32 immediate_max_possible_score = 3; */
+        if (message.immediateMaxPossibleScore !== 0)
+            writer.tag(3, WireType.Varint).int32(message.immediateMaxPossibleScore);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayScoreEvent
+ */
+export const ReplayScoreEvent = new ReplayScoreEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayComboEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayComboEvent", [
+            { no: 1, name: "combo", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.combo = 0;
+        message.timeSeconds = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 combo */ 1:
+                    message.combo = reader.int32();
+                    break;
+                case /* float time_seconds */ 2:
+                    message.timeSeconds = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int32 combo = 1; */
+        if (message.combo !== 0)
+            writer.tag(1, WireType.Varint).int32(message.combo);
+        /* float time_seconds = 2; */
+        if (message.timeSeconds !== 0)
+            writer.tag(2, WireType.Bit32).float(message.timeSeconds);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayComboEvent
+ */
+export const ReplayComboEvent = new ReplayComboEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayMultiplierEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayMultiplierEvent", [
+            { no: 1, name: "multiplier", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "next_multiplier_progress", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.multiplier = 0;
+        message.nextMultiplierProgress = 0;
+        message.timeSeconds = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 multiplier */ 1:
+                    message.multiplier = reader.int32();
+                    break;
+                case /* float next_multiplier_progress */ 2:
+                    message.nextMultiplierProgress = reader.float();
+                    break;
+                case /* float time_seconds */ 3:
+                    message.timeSeconds = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int32 multiplier = 1; */
+        if (message.multiplier !== 0)
+            writer.tag(1, WireType.Varint).int32(message.multiplier);
+        /* float next_multiplier_progress = 2; */
+        if (message.nextMultiplierProgress !== 0)
+            writer.tag(2, WireType.Bit32).float(message.nextMultiplierProgress);
+        /* float time_seconds = 3; */
+        if (message.timeSeconds !== 0)
+            writer.tag(3, WireType.Bit32).float(message.timeSeconds);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayMultiplierEvent
+ */
+export const ReplayMultiplierEvent = new ReplayMultiplierEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayEnergyEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayEnergyEvent", [
+            { no: 1, name: "energy", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.energy = 0;
+        message.timeSeconds = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float energy */ 1:
+                    message.energy = reader.float();
+                    break;
+                case /* float time_seconds */ 2:
+                    message.timeSeconds = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* float energy = 1; */
+        if (message.energy !== 0)
+            writer.tag(1, WireType.Bit32).float(message.energy);
+        /* float time_seconds = 2; */
+        if (message.timeSeconds !== 0)
+            writer.tag(2, WireType.Bit32).float(message.timeSeconds);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayEnergyEvent
+ */
+export const ReplayEnergyEvent = new ReplayEnergyEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayPauseEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayPauseEvent", [
+            { no: 1, name: "paused", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 3, name: "client_time_unix_ms", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.paused = false;
+        message.timeSeconds = 0;
+        message.clientTimeUnixMs = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool paused */ 1:
+                    message.paused = reader.bool();
+                    break;
+                case /* float time_seconds */ 2:
+                    message.timeSeconds = reader.float();
+                    break;
+                case /* int64 client_time_unix_ms */ 3:
+                    message.clientTimeUnixMs = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool paused = 1; */
+        if (message.paused !== false)
+            writer.tag(1, WireType.Varint).bool(message.paused);
+        /* float time_seconds = 2; */
+        if (message.timeSeconds !== 0)
+            writer.tag(2, WireType.Bit32).float(message.timeSeconds);
+        /* int64 client_time_unix_ms = 3; */
+        if (message.clientTimeUnixMs !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.clientTimeUnixMs);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayPauseEvent
+ */
+export const ReplayPauseEvent = new ReplayPauseEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayNoteEvent$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayNoteEvent", [
+            { no: 1, name: "note_id", kind: "message", T: () => ReplayNoteId },
+            { no: 2, name: "event_type", kind: "enum", T: () => ["proto.replay.ReplayNoteEventType", ReplayNoteEventType, "REPLAY_NOTE_EVENT_TYPE_"] },
+            { no: 3, name: "cut_point", kind: "message", T: () => ReplayVector3 },
+            { no: 4, name: "cut_normal", kind: "message", T: () => ReplayVector3 },
+            { no: 5, name: "saber_direction", kind: "message", T: () => ReplayVector3 },
+            { no: 6, name: "saber_type", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 7, name: "direction_ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "saber_speed", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 9, name: "cut_angle", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 10, name: "cut_distance_to_center", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 11, name: "cut_direction_deviation", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 12, name: "before_cut_rating", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 13, name: "after_cut_rating", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 14, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 15, name: "unity_timescale", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 16, name: "time_sync_timescale", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 17, name: "time_deviation", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 18, name: "world_rotation", kind: "message", T: () => ReplayQuaternion },
+            { no: 19, name: "inverse_world_rotation", kind: "message", T: () => ReplayQuaternion },
+            { no: 20, name: "note_rotation", kind: "message", T: () => ReplayQuaternion },
+            { no: 21, name: "note_position", kind: "message", T: () => ReplayVector3 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.eventType = 0;
+        message.saberType = 0;
+        message.directionOk = false;
+        message.saberSpeed = 0;
+        message.cutAngle = 0;
+        message.cutDistanceToCenter = 0;
+        message.cutDirectionDeviation = 0;
+        message.beforeCutRating = 0;
+        message.afterCutRating = 0;
+        message.timeSeconds = 0;
+        message.unityTimescale = 0;
+        message.timeSyncTimescale = 0;
+        message.timeDeviation = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* proto.replay.ReplayNoteId note_id */ 1:
+                    message.noteId = ReplayNoteId.internalBinaryRead(reader, reader.uint32(), options, message.noteId);
+                    break;
+                case /* proto.replay.ReplayNoteEventType event_type */ 2:
+                    message.eventType = reader.int32();
+                    break;
+                case /* proto.replay.ReplayVector3 cut_point */ 3:
+                    message.cutPoint = ReplayVector3.internalBinaryRead(reader, reader.uint32(), options, message.cutPoint);
+                    break;
+                case /* proto.replay.ReplayVector3 cut_normal */ 4:
+                    message.cutNormal = ReplayVector3.internalBinaryRead(reader, reader.uint32(), options, message.cutNormal);
+                    break;
+                case /* proto.replay.ReplayVector3 saber_direction */ 5:
+                    message.saberDirection = ReplayVector3.internalBinaryRead(reader, reader.uint32(), options, message.saberDirection);
+                    break;
+                case /* int32 saber_type */ 6:
+                    message.saberType = reader.int32();
+                    break;
+                case /* bool direction_ok */ 7:
+                    message.directionOk = reader.bool();
+                    break;
+                case /* float saber_speed */ 8:
+                    message.saberSpeed = reader.float();
+                    break;
+                case /* float cut_angle */ 9:
+                    message.cutAngle = reader.float();
+                    break;
+                case /* float cut_distance_to_center */ 10:
+                    message.cutDistanceToCenter = reader.float();
+                    break;
+                case /* float cut_direction_deviation */ 11:
+                    message.cutDirectionDeviation = reader.float();
+                    break;
+                case /* float before_cut_rating */ 12:
+                    message.beforeCutRating = reader.float();
+                    break;
+                case /* float after_cut_rating */ 13:
+                    message.afterCutRating = reader.float();
+                    break;
+                case /* float time_seconds */ 14:
+                    message.timeSeconds = reader.float();
+                    break;
+                case /* float unity_timescale */ 15:
+                    message.unityTimescale = reader.float();
+                    break;
+                case /* float time_sync_timescale */ 16:
+                    message.timeSyncTimescale = reader.float();
+                    break;
+                case /* float time_deviation */ 17:
+                    message.timeDeviation = reader.float();
+                    break;
+                case /* proto.replay.ReplayQuaternion world_rotation */ 18:
+                    message.worldRotation = ReplayQuaternion.internalBinaryRead(reader, reader.uint32(), options, message.worldRotation);
+                    break;
+                case /* proto.replay.ReplayQuaternion inverse_world_rotation */ 19:
+                    message.inverseWorldRotation = ReplayQuaternion.internalBinaryRead(reader, reader.uint32(), options, message.inverseWorldRotation);
+                    break;
+                case /* proto.replay.ReplayQuaternion note_rotation */ 20:
+                    message.noteRotation = ReplayQuaternion.internalBinaryRead(reader, reader.uint32(), options, message.noteRotation);
+                    break;
+                case /* proto.replay.ReplayVector3 note_position */ 21:
+                    message.notePosition = ReplayVector3.internalBinaryRead(reader, reader.uint32(), options, message.notePosition);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* proto.replay.ReplayNoteId note_id = 1; */
+        if (message.noteId)
+            ReplayNoteId.internalBinaryWrite(message.noteId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayNoteEventType event_type = 2; */
+        if (message.eventType !== 0)
+            writer.tag(2, WireType.Varint).int32(message.eventType);
+        /* proto.replay.ReplayVector3 cut_point = 3; */
+        if (message.cutPoint)
+            ReplayVector3.internalBinaryWrite(message.cutPoint, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayVector3 cut_normal = 4; */
+        if (message.cutNormal)
+            ReplayVector3.internalBinaryWrite(message.cutNormal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayVector3 saber_direction = 5; */
+        if (message.saberDirection)
+            ReplayVector3.internalBinaryWrite(message.saberDirection, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* int32 saber_type = 6; */
+        if (message.saberType !== 0)
+            writer.tag(6, WireType.Varint).int32(message.saberType);
+        /* bool direction_ok = 7; */
+        if (message.directionOk !== false)
+            writer.tag(7, WireType.Varint).bool(message.directionOk);
+        /* float saber_speed = 8; */
+        if (message.saberSpeed !== 0)
+            writer.tag(8, WireType.Bit32).float(message.saberSpeed);
+        /* float cut_angle = 9; */
+        if (message.cutAngle !== 0)
+            writer.tag(9, WireType.Bit32).float(message.cutAngle);
+        /* float cut_distance_to_center = 10; */
+        if (message.cutDistanceToCenter !== 0)
+            writer.tag(10, WireType.Bit32).float(message.cutDistanceToCenter);
+        /* float cut_direction_deviation = 11; */
+        if (message.cutDirectionDeviation !== 0)
+            writer.tag(11, WireType.Bit32).float(message.cutDirectionDeviation);
+        /* float before_cut_rating = 12; */
+        if (message.beforeCutRating !== 0)
+            writer.tag(12, WireType.Bit32).float(message.beforeCutRating);
+        /* float after_cut_rating = 13; */
+        if (message.afterCutRating !== 0)
+            writer.tag(13, WireType.Bit32).float(message.afterCutRating);
+        /* float time_seconds = 14; */
+        if (message.timeSeconds !== 0)
+            writer.tag(14, WireType.Bit32).float(message.timeSeconds);
+        /* float unity_timescale = 15; */
+        if (message.unityTimescale !== 0)
+            writer.tag(15, WireType.Bit32).float(message.unityTimescale);
+        /* float time_sync_timescale = 16; */
+        if (message.timeSyncTimescale !== 0)
+            writer.tag(16, WireType.Bit32).float(message.timeSyncTimescale);
+        /* float time_deviation = 17; */
+        if (message.timeDeviation !== 0)
+            writer.tag(17, WireType.Bit32).float(message.timeDeviation);
+        /* proto.replay.ReplayQuaternion world_rotation = 18; */
+        if (message.worldRotation)
+            ReplayQuaternion.internalBinaryWrite(message.worldRotation, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayQuaternion inverse_world_rotation = 19; */
+        if (message.inverseWorldRotation)
+            ReplayQuaternion.internalBinaryWrite(message.inverseWorldRotation, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayQuaternion note_rotation = 20; */
+        if (message.noteRotation)
+            ReplayQuaternion.internalBinaryWrite(message.noteRotation, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
+        /* proto.replay.ReplayVector3 note_position = 21; */
+        if (message.notePosition)
+            ReplayVector3.internalBinaryWrite(message.notePosition, writer.tag(21, 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.replay.ReplayNoteEvent
+ */
+export const ReplayNoteEvent = new ReplayNoteEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayNoteId$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayNoteId", [
+            { no: 1, name: "time_seconds", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ },
+            { no: 2, name: "line_layer", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "line_index", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "color_type", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 5, name: "cut_direction", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 6, name: "gameplay_type", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 7, name: "scoring_type", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 8, name: "cut_direction_angle_offset", kind: "scalar", T: 2 /*ScalarType.FLOAT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.timeSeconds = 0;
+        message.lineLayer = 0;
+        message.lineIndex = 0;
+        message.colorType = 0;
+        message.cutDirection = 0;
+        message.gameplayType = 0;
+        message.scoringType = 0;
+        message.cutDirectionAngleOffset = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* float time_seconds */ 1:
+                    message.timeSeconds = reader.float();
+                    break;
+                case /* int32 line_layer */ 2:
+                    message.lineLayer = reader.int32();
+                    break;
+                case /* int32 line_index */ 3:
+                    message.lineIndex = reader.int32();
+                    break;
+                case /* int32 color_type */ 4:
+                    message.colorType = reader.int32();
+                    break;
+                case /* int32 cut_direction */ 5:
+                    message.cutDirection = reader.int32();
+                    break;
+                case /* int32 gameplay_type */ 6:
+                    message.gameplayType = reader.int32();
+                    break;
+                case /* int32 scoring_type */ 7:
+                    message.scoringType = reader.int32();
+                    break;
+                case /* float cut_direction_angle_offset */ 8:
+                    message.cutDirectionAngleOffset = reader.float();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* float time_seconds = 1; */
+        if (message.timeSeconds !== 0)
+            writer.tag(1, WireType.Bit32).float(message.timeSeconds);
+        /* int32 line_layer = 2; */
+        if (message.lineLayer !== 0)
+            writer.tag(2, WireType.Varint).int32(message.lineLayer);
+        /* int32 line_index = 3; */
+        if (message.lineIndex !== 0)
+            writer.tag(3, WireType.Varint).int32(message.lineIndex);
+        /* int32 color_type = 4; */
+        if (message.colorType !== 0)
+            writer.tag(4, WireType.Varint).int32(message.colorType);
+        /* int32 cut_direction = 5; */
+        if (message.cutDirection !== 0)
+            writer.tag(5, WireType.Varint).int32(message.cutDirection);
+        /* int32 gameplay_type = 6; */
+        if (message.gameplayType !== 0)
+            writer.tag(6, WireType.Varint).int32(message.gameplayType);
+        /* int32 scoring_type = 7; */
+        if (message.scoringType !== 0)
+            writer.tag(7, WireType.Varint).int32(message.scoringType);
+        /* float cut_direction_angle_offset = 8; */
+        if (message.cutDirectionAngleOffset !== 0)
+            writer.tag(8, WireType.Bit32).float(message.cutDirectionAngleOffset);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayNoteId
+ */
+export const ReplayNoteId = new ReplayNoteId$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplayScoreSummary$Type extends MessageType {
+    constructor() {
+        super("proto.replay.ReplayScoreSummary", [
+            { no: 1, name: "score", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "modified_score", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 3, name: "max_score", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 4, name: "accuracy", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 5, name: "combo", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 6, name: "max_combo", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 7, name: "full_combo", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "good_cuts", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 9, name: "bad_cuts", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 10, name: "missed_notes", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 11, name: "bomb_hits", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 12, name: "wall_hits", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.score = 0;
+        message.modifiedScore = 0;
+        message.maxScore = 0;
+        message.accuracy = 0;
+        message.combo = 0;
+        message.maxCombo = 0;
+        message.fullCombo = false;
+        message.goodCuts = 0;
+        message.badCuts = 0;
+        message.missedNotes = 0;
+        message.bombHits = 0;
+        message.wallHits = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 score */ 1:
+                    message.score = reader.uint32();
+                    break;
+                case /* uint32 modified_score */ 2:
+                    message.modifiedScore = reader.uint32();
+                    break;
+                case /* uint32 max_score */ 3:
+                    message.maxScore = reader.uint32();
+                    break;
+                case /* double accuracy */ 4:
+                    message.accuracy = reader.double();
+                    break;
+                case /* uint32 combo */ 5:
+                    message.combo = reader.uint32();
+                    break;
+                case /* uint32 max_combo */ 6:
+                    message.maxCombo = reader.uint32();
+                    break;
+                case /* bool full_combo */ 7:
+                    message.fullCombo = reader.bool();
+                    break;
+                case /* uint32 good_cuts */ 8:
+                    message.goodCuts = reader.uint32();
+                    break;
+                case /* uint32 bad_cuts */ 9:
+                    message.badCuts = reader.uint32();
+                    break;
+                case /* uint32 missed_notes */ 10:
+                    message.missedNotes = reader.uint32();
+                    break;
+                case /* uint32 bomb_hits */ 11:
+                    message.bombHits = reader.uint32();
+                    break;
+                case /* uint32 wall_hits */ 12:
+                    message.wallHits = reader.uint32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint32 score = 1; */
+        if (message.score !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.score);
+        /* uint32 modified_score = 2; */
+        if (message.modifiedScore !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.modifiedScore);
+        /* uint32 max_score = 3; */
+        if (message.maxScore !== 0)
+            writer.tag(3, WireType.Varint).uint32(message.maxScore);
+        /* double accuracy = 4; */
+        if (message.accuracy !== 0)
+            writer.tag(4, WireType.Bit64).double(message.accuracy);
+        /* uint32 combo = 5; */
+        if (message.combo !== 0)
+            writer.tag(5, WireType.Varint).uint32(message.combo);
+        /* uint32 max_combo = 6; */
+        if (message.maxCombo !== 0)
+            writer.tag(6, WireType.Varint).uint32(message.maxCombo);
+        /* bool full_combo = 7; */
+        if (message.fullCombo !== false)
+            writer.tag(7, WireType.Varint).bool(message.fullCombo);
+        /* uint32 good_cuts = 8; */
+        if (message.goodCuts !== 0)
+            writer.tag(8, WireType.Varint).uint32(message.goodCuts);
+        /* uint32 bad_cuts = 9; */
+        if (message.badCuts !== 0)
+            writer.tag(9, WireType.Varint).uint32(message.badCuts);
+        /* uint32 missed_notes = 10; */
+        if (message.missedNotes !== 0)
+            writer.tag(10, WireType.Varint).uint32(message.missedNotes);
+        /* uint32 bomb_hits = 11; */
+        if (message.bombHits !== 0)
+            writer.tag(11, WireType.Varint).uint32(message.bombHits);
+        /* uint32 wall_hits = 12; */
+        if (message.wallHits !== 0)
+            writer.tag(12, WireType.Varint).uint32(message.wallHits);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message proto.replay.ReplayScoreSummary
+ */
+export const ReplayScoreSummary = new ReplayScoreSummary$Type();