From 43fd9302d6b82e5696de001d2f77f6894036d94c Mon Sep 17 00:00:00 2001 From: xeon Date: Tue, 25 Jun 2024 21:30:33 +0300 Subject: [PATCH] First push --- .gitignore | 22 + build.zig | 51 + build.zig.zon | 15 + dispatch/build.zig | 35 + dispatch/build.zig.zon | 28 + dispatch/src/authentication.zig | 48 + dispatch/src/dispatch.zig | 56 + dispatch/src/main.zig | 22 + gameserver/build.zig | 28 + gameserver/build.zig.zon | 18 + gameserver/src/Packet.zig | 75 + gameserver/src/Session.zig | 54 + gameserver/src/handlers.zig | 93 + gameserver/src/main.zig | 10 + gameserver/src/network.zig | 36 + gameserver/src/services/avatar.zig | 31 + gameserver/src/services/battle.zig | 50 + gameserver/src/services/lineup.zig | 26 + gameserver/src/services/login.zig | 32 + gameserver/src/services/misc.zig | 26 + gameserver/src/services/mission.zig | 96 + gameserver/src/services/scene.zig | 76 + protocol/build.zig | 18 + protocol/build.zig.zon | 15 + protocol/src/protocol.pb.zig | 36306 ++++++++++++++++++++++++++ protocol/src/root.zig | 1557 ++ 26 files changed, 38824 insertions(+) create mode 100644 .gitignore create mode 100644 build.zig create mode 100644 build.zig.zon create mode 100644 dispatch/build.zig create mode 100644 dispatch/build.zig.zon create mode 100644 dispatch/src/authentication.zig create mode 100644 dispatch/src/dispatch.zig create mode 100644 dispatch/src/main.zig create mode 100644 gameserver/build.zig create mode 100644 gameserver/build.zig.zon create mode 100644 gameserver/src/Packet.zig create mode 100644 gameserver/src/Session.zig create mode 100644 gameserver/src/handlers.zig create mode 100644 gameserver/src/main.zig create mode 100644 gameserver/src/network.zig create mode 100644 gameserver/src/services/avatar.zig create mode 100644 gameserver/src/services/battle.zig create mode 100644 gameserver/src/services/lineup.zig create mode 100644 gameserver/src/services/login.zig create mode 100644 gameserver/src/services/misc.zig create mode 100644 gameserver/src/services/mission.zig create mode 100644 gameserver/src/services/scene.zig create mode 100644 protocol/build.zig create mode 100644 protocol/build.zig.zon create mode 100644 protocol/src/protocol.pb.zig create mode 100644 protocol/src/root.zig diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e32a90c --- /dev/null +++ b/.gitignore @@ -0,0 +1,22 @@ +# This file is for zig-specific build artifacts. +# If you have OS-specific or editor-specific files to ignore, +# such as *.swp or .DS_Store, put those in your global +# ~/.gitignore and put this in your ~/.gitconfig: +# +# [core] +# excludesfile = ~/.gitignore + +.zig-cache/ +zig-out/ +/release/ +/debug/ +/build/ +/build-*/ +/docgen_tmp/ + +# Although this was renamed to .zig-cache, let's leave it here for a few +# releases to make it less annoying to work with multiple branches. +zig-cache/ + +protocol/StarRail.proto +protocol/nameTranslation.txt diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..7dbd122 --- /dev/null +++ b/build.zig @@ -0,0 +1,51 @@ +const std = @import("std"); +const protobuf = @import("protobuf"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const dep_opts = .{ .target = target, .optimize = optimize }; + + const protobuf_dep = b.dependency("protobuf", dep_opts); + + if (std.fs.cwd().access("protocol/StarRail.proto", .{})) { + const protoc_step = protobuf.RunProtocStep.create(b, protobuf_dep.builder, target, .{ + .destination_directory = b.path("protocol/src"), + .source_files = &.{ + "protocol/StarRail.proto", + }, + .include_directories = &.{}, + }); + + b.getInstallStep().dependOn(&protoc_step.step); + } else |_| {} // don't invoke protoc if proto definition doesn't exist + + const dispatch = b.dependency("dispatch", dep_opts); + b.installArtifact(dispatch.artifact("dispatch")); + + const gameserver = b.dependency("gameserver", dep_opts); + b.installArtifact(gameserver.artifact("gameserver")); + + // "run-dispatch" command + const dispatch_cmd = b.addRunArtifact(dispatch.artifact("dispatch")); + dispatch_cmd.step.dependOn(b.getInstallStep()); + + if (b.args) |args| { + dispatch_cmd.addArgs(args); + } + + const dispatch_step = b.step("run-dispatch", "Run the dispatch server"); + dispatch_step.dependOn(&dispatch_cmd.step); + + // "run-gameserver" command + const gameserver_cmd = b.addRunArtifact(gameserver.artifact("gameserver")); + gameserver_cmd.step.dependOn(b.getInstallStep()); + + if (b.args) |args| { + gameserver_cmd.addArgs(args); + } + + const gameserver_step = b.step("run-gameserver", "Run the game server"); + gameserver_step.dependOn(&gameserver_cmd.step); +} diff --git a/build.zig.zon b/build.zig.zon new file mode 100644 index 0000000..91770d4 --- /dev/null +++ b/build.zig.zon @@ -0,0 +1,15 @@ +.{ + .name = "YunliSR", + .version = "0.0.1", + .minimum_zig_version = "0.13.0", + .dependencies = .{ + .dispatch = .{ .path = "dispatch" }, + .gameserver = .{ .path = "gameserver" }, + .protocol = .{ .path = "protocol" }, + .protobuf = .{ + .url = "https://github.com/Arwalk/zig-protobuf/archive/7c49ed66e029c9c7e6253b3d6d256118745550a4.tar.gz", + .hash = "122063ee7ff32a3c1aefd91a46a9fc23df0571949c3a02e2f44d39afbad0b53018a3", + }, + }, + .paths = .{""}, +} diff --git a/dispatch/build.zig b/dispatch/build.zig new file mode 100644 index 0000000..4f769ff --- /dev/null +++ b/dispatch/build.zig @@ -0,0 +1,35 @@ +const std = @import("std"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const httpz = b.dependency("httpz", .{ + .optimize = optimize, + .target = target, + }); + + const protocol = b.dependency("protocol", .{}); + + const exe = b.addExecutable(.{ + .name = "dispatch", + .root_source_file = b.path("src/main.zig"), + .target = target, + .optimize = optimize, + }); + + exe.root_module.addImport("httpz", httpz.module("httpz")); + exe.root_module.addImport("protocol", protocol.module("protocol")); + + b.installArtifact(exe); + + const run_cmd = b.addRunArtifact(exe); + run_cmd.step.dependOn(b.getInstallStep()); + + if (b.args) |args| { + run_cmd.addArgs(args); + } + + const run_step = b.step("run", "Run the app"); + run_step.dependOn(&run_cmd.step); +} diff --git a/dispatch/build.zig.zon b/dispatch/build.zig.zon new file mode 100644 index 0000000..5cf648f --- /dev/null +++ b/dispatch/build.zig.zon @@ -0,0 +1,28 @@ +.{ + .name = "dispatch", + .version = "0.0.1", + .minimum_zig_version = "0.13.0", + + // This field is optional. + // Each dependency must either provide a `url` and `hash`, or a `path`. + // `zig build --fetch` can be used to fetch all dependencies of a package, recursively. + // Once all dependencies are fetched, `zig build` no longer requires + // internet connectivity. + .dependencies = .{ + .httpz = .{ + .url = "https://github.com/karlseguin/http.zig/archive/406fb00f8c43fe9b2da0f32f428675755c67d054.tar.gz", + .hash = "12209e87663712928c6ae1c690e65df15a796e970e5d18f5e4e05f0eb10404883d23", + }, + .protocol = .{ + .path = "../protocol", + }, + }, + .paths = .{ + "build.zig", + "build.zig.zon", + "src", + // For example... + //"LICENSE", + //"README.md", + }, +} diff --git a/dispatch/src/authentication.zig b/dispatch/src/authentication.zig new file mode 100644 index 0000000..2858b6c --- /dev/null +++ b/dispatch/src/authentication.zig @@ -0,0 +1,48 @@ +const std = @import("std"); +const httpz = @import("httpz"); + +pub fn onShieldLogin(_: *httpz.Request, res: *httpz.Response) !void { + std.log.debug("onShieldLogin", .{}); + + try res.json(.{ + .retcode = 0, + .message = "OK", + .data = .{ + .account = .{ + .area_code = "**", + .email = "reversedrooms@xeondev.com", + .country = "RU", + .is_email_verify = "1", + .token = "mostsecuretokenever", + .uid = "1337", + }, + }, + }, .{}); +} + +pub fn onComboTokenReq(_: *httpz.Request, res: *httpz.Response) !void { + std.log.debug("onComboTokenReq", .{}); + + try res.json(.{ + .retcode = 0, + .message = "OK", + .data = .{ + .account_type = 1, + .open_id = "1337", + .combo_id = "1337", + .combo_token = "mostsecuretokenever", + .heartbeat = false, + .data = "{\"guest\": false}", + }, + }, .{}); +} + +pub fn onRiskyApiCheck(_: *httpz.Request, res: *httpz.Response) !void { + std.log.debug("onRiskyApiCheck", .{}); + + try res.json(.{ + .retcode = 0, + .message = "OK", + .data = .{ .id = "" }, + }, .{}); +} diff --git a/dispatch/src/dispatch.zig b/dispatch/src/dispatch.zig new file mode 100644 index 0000000..b5653bf --- /dev/null +++ b/dispatch/src/dispatch.zig @@ -0,0 +1,56 @@ +const std = @import("std"); +const httpz = @import("httpz"); +const protocol = @import("protocol"); +const Base64Encoder = @import("std").base64.standard.Encoder; + +pub fn onQueryDispatch(_: *httpz.Request, res: *httpz.Response) !void { + std.log.debug("onQueryDispatch", .{}); + + var proto = protocol.GlobalDispatchData.init(res.arena); + + proto.retcode = 0; + try proto.server_list.append(.{ + .name = .{ .Const = "YunliSR" }, + .display_name = .{ .Const = "YunliSR" }, + .env_type = .{ .Const = "2" }, + .title = .{ .Const = "YunliSR" }, + .dispatch_url = .{ .Const = "http://127.0.0.1:21000/query_gateway" }, + }); + + const data = try proto.encode(res.arena); + const size = Base64Encoder.calcSize(data.len); + const output = try res.arena.alloc(u8, size); + _ = Base64Encoder.encode(output, data); + + res.body = output; +} + +pub fn onQueryGateway(_: *httpz.Request, res: *httpz.Response) !void { + std.log.debug("onQueryGateway", .{}); + + var proto = protocol.Gateserver.init(res.arena); + + proto.retcode = 0; + proto.use_tcp = true; + proto.port = 23301; + proto.ip = .{ .Const = "127.0.0.1" }; + proto.lua_version = .{ .Const = "7327274" }; + proto.ifix_version = .{ .Const = "0" }; + proto.lua_url = .{ .Const = "https://autopatchos.starrails.com/lua/BetaLive/output_7327274_d12d75929650" }; + proto.asset_bundle_url = .{ .Const = "https://autopatchos.starrails.com/asb/BetaLive/output_7327119_c52eec0f6a92" }; + proto.ex_resource_url = .{ .Const = "https://autopatchos.starrails.com/design_data/BetaLive/output_7349339_419592cb2562" }; + proto.MCANJEHAEKO = true; + proto.PGMFEHFKLBG = true; + proto.NNPPEAAIHAK = true; + proto.LGPAAPCPBMD = true; + proto.GNFPFKJHIDJ = true; + proto.FKFKCDJNHFL = true; + proto.AOEKIKFKMGA = true; + + const data = try proto.encode(res.arena); + const size = Base64Encoder.calcSize(data.len); + const output = try res.arena.alloc(u8, size); + _ = Base64Encoder.encode(output, data); + + res.body = output; +} diff --git a/dispatch/src/main.zig b/dispatch/src/main.zig new file mode 100644 index 0000000..149ae11 --- /dev/null +++ b/dispatch/src/main.zig @@ -0,0 +1,22 @@ +const std = @import("std"); +const httpz = @import("httpz"); +const protocol = @import("protocol"); + +const authentication = @import("authentication.zig"); +const dispatch = @import("dispatch.zig"); + +pub fn main() !void { + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + const allocator = gpa.allocator(); + + var server = try httpz.Server().init(allocator, .{ .port = 21000 }); + var router = server.router(); + + router.get("/query_dispatch", dispatch.onQueryDispatch); + router.get("/query_gateway", dispatch.onQueryGateway); + router.post("/account/risky/api/check", authentication.onRiskyApiCheck); + router.post("/:product_name/mdk/shield/api/login", authentication.onShieldLogin); + router.post("/:product_name/combo/granter/login/v2/login", authentication.onComboTokenReq); + + try server.listen(); +} diff --git a/gameserver/build.zig b/gameserver/build.zig new file mode 100644 index 0000000..ab00344 --- /dev/null +++ b/gameserver/build.zig @@ -0,0 +1,28 @@ +const std = @import("std"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const protocol = b.dependency("protocol", .{}); + + const exe = b.addExecutable(.{ + .name = "gameserver", + .root_source_file = b.path("src/main.zig"), + .target = target, + .optimize = optimize, + }); + + exe.root_module.addImport("protocol", protocol.module("protocol")); + b.installArtifact(exe); + + const run_cmd = b.addRunArtifact(exe); + run_cmd.step.dependOn(b.getInstallStep()); + + if (b.args) |args| { + run_cmd.addArgs(args); + } + + const run_step = b.step("run", "Run the app"); + run_step.dependOn(&run_cmd.step); +} diff --git a/gameserver/build.zig.zon b/gameserver/build.zig.zon new file mode 100644 index 0000000..a8c8ad4 --- /dev/null +++ b/gameserver/build.zig.zon @@ -0,0 +1,18 @@ +.{ + .name = "gameserver", + .version = "0.0.0", + .minimum_zig_version = "0.13.0", + .dependencies = .{ + .protocol = .{ + .path = "../protocol", + }, + }, + .paths = .{ + "build.zig", + "build.zig.zon", + "src", + // For example... + //"LICENSE", + //"README.md", + }, +} diff --git a/gameserver/src/Packet.zig b/gameserver/src/Packet.zig new file mode 100644 index 0000000..7b410d6 --- /dev/null +++ b/gameserver/src/Packet.zig @@ -0,0 +1,75 @@ +const std = @import("std"); +const Allocator = std.mem.Allocator; +const Reader = std.net.Stream.Reader; +const Self = @This(); + +cmd_id: u16, +head: []u8, +body: []u8, +allocator: Allocator, + +const head_magic: u32 = 0x9D74C714; +const tail_magic: u32 = 0xD7A152C8; + +pub const DecodeError = error{ + HeadMagicMismatch, + TailMagicMismatch, + PayloadTooBig, +}; + +pub fn read(reader: *Reader, allocator: Allocator) !Self { + if (try reader.readInt(u32, .big) != Self.head_magic) { + return Self.DecodeError.HeadMagicMismatch; + } + + const cmd_id = try reader.readInt(u16, .big); + const head_len = try reader.readInt(u16, .big); + const body_len = try reader.readInt(u32, .big); + + if (body_len > 0xFFFFFF) { + return Self.DecodeError.PayloadTooBig; + } + + const head = try allocator.alloc(u8, head_len); + errdefer allocator.free(head); + + const body = try allocator.alloc(u8, body_len); + errdefer allocator.free(body); + + _ = try reader.readAll(head); + _ = try reader.readAll(body); + + if (try reader.readInt(u32, .big) != Self.tail_magic) { + return Self.DecodeError.TailMagicMismatch; + } + + return .{ + .cmd_id = cmd_id, + .head = head, + .body = body, + .allocator = allocator, + }; +} + +pub fn getProto(self: *const Self, comptime T: type, allocator: Allocator) !T { + return try T.decode(self.body, allocator); +} + +pub fn encode(cmd_id: u16, head: []u8, body: []u8, allocator: Allocator) ![]u8 { + var buf = try allocator.alloc(u8, 16 + head.len + body.len); + + std.mem.writeInt(u32, buf[0..4], Self.head_magic, .big); + std.mem.writeInt(u16, buf[4..6], cmd_id, .big); + std.mem.writeInt(u16, buf[6..8], @intCast(head.len), .big); + std.mem.writeInt(u32, buf[8..12], @intCast(body.len), .big); + @memcpy(buf[12..(12 + head.len)], head); + @memcpy(buf[(12 + head.len)..(12 + head.len + body.len)], body); + std.mem.writeInt(u32, buf[(12 + head.len + body.len)..][0..4], Self.tail_magic, .big); + + return buf; +} + +pub fn deinit(self: *Self) void { + self.allocator.free(self.head); + self.allocator.free(self.body); +} diff --git a/gameserver/src/Session.zig b/gameserver/src/Session.zig new file mode 100644 index 0000000..5e9f317 --- /dev/null +++ b/gameserver/src/Session.zig @@ -0,0 +1,54 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const handlers = @import("handlers.zig"); +const Packet = @import("Packet.zig"); +const Allocator = std.mem.Allocator; +const ArenaAllocator = std.heap.ArenaAllocator; + +const Stream = std.net.Stream; +const Address = std.net.Address; + +const Self = @This(); + +address: Address, +stream: Stream, +allocator: Allocator, + +pub fn init(address: Address, stream: Stream, allocator: Allocator) Self { + return .{ + .address = address, + .stream = stream, + .allocator = allocator, + }; +} + +pub fn run(self: *Self) !void { + defer self.stream.close(); + + var reader = self.stream.reader(); + while (true) { + var packet = Packet.read(&reader, self.allocator) catch break; + defer packet.deinit(); + + try handlers.handle(self, &packet); + } +} + +pub fn send(self: *Self, cmd_id: protocol.CmdID, proto: anytype) !void { + const data = try proto.encode(self.allocator); + defer self.allocator.free(data); + + const packet = try Packet.encode(@intFromEnum(cmd_id), &.{}, data, self.allocator); + defer self.allocator.free(packet); + + _ = try self.stream.write(packet); + std.log.debug("sent packet with id {}", .{cmd_id}); +} + +pub fn send_empty(self: *Self, cmd_id: protocol.CmdID) !void { + const packet = try Packet.encode(@intFromEnum(cmd_id), &.{}, &.{}, self.allocator); + defer self.allocator.free(packet); + + _ = try self.stream.write(packet); + std.log.debug("sent EMPTY packet with id {}", .{cmd_id}); +} diff --git a/gameserver/src/handlers.zig b/gameserver/src/handlers.zig new file mode 100644 index 0000000..1bbe5ce --- /dev/null +++ b/gameserver/src/handlers.zig @@ -0,0 +1,93 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const Session = @import("Session.zig"); +const Packet = @import("Packet.zig"); +const avatar = @import("services/avatar.zig"); +const battle = @import("services/battle.zig"); +const login = @import("services/login.zig"); +const lineup = @import("services/lineup.zig"); +const mission = @import("services/mission.zig"); +const scene = @import("services/scene.zig"); +const misc = @import("services/misc.zig"); + +const Allocator = std.mem.Allocator; +const ArenaAllocator = std.heap.ArenaAllocator; +const CmdID = protocol.CmdID; + +const Action = *const fn (*Session, *const Packet, Allocator) anyerror!void; +const HandlerList = [_]struct { CmdID, Action }{ + .{ CmdID.CmdPlayerGetTokenCsReq, login.onPlayerGetToken }, + .{ CmdID.CmdPlayerLoginCsReq, login.onPlayerLogin }, + .{ CmdID.CmdPlayerHeartBeatCsReq, misc.onPlayerHeartBeat }, + .{ CmdID.CmdGetAvatarDataCsReq, avatar.onGetAvatarData }, + .{ CmdID.CmdGetMissionStatusCsReq, mission.onGetMissionStatus }, + .{ CmdID.CmdGetCurLineupDataCsReq, lineup.onGetCurLineupData }, + .{ CmdID.CmdGetCurSceneInfoCsReq, scene.onGetCurSceneInfo }, + .{ CmdID.CmdSceneEntityMoveCsReq, scene.onSceneEntityMove }, + .{ CmdID.CmdStartCocoonStageCsReq, battle.onStartCocoonStage }, + .{ CmdID.CmdPVEBattleResultCsReq, battle.onPVEBattleResult }, +}; + +const DummyCmdList = [_]struct { CmdID, CmdID }{ + .{ CmdID.CmdGetBasicInfoCsReq, CmdID.CmdGetBasicInfoScRsp }, + .{ CmdID.CmdGetMultiPathAvatarInfoCsReq, CmdID.CmdGetMultiPathAvatarInfoScRsp }, + .{ CmdID.CmdGetBagCsReq, CmdID.CmdGetBagScRsp }, + .{ CmdID.CmdGetMarkItemListCsReq, CmdID.CmdGetMarkItemListScRsp }, + .{ CmdID.CmdGetPlayerBoardDataCsReq, CmdID.CmdGetPlayerBoardDataScRsp }, + .{ CmdID.CmdGetCurAssistCsReq, CmdID.CmdGetCurAssistScRsp }, + .{ CmdID.CmdGetAllLineupDataCsReq, CmdID.CmdGetAllLineupDataScRsp }, + .{ CmdID.CmdGetAllServerPrefsDataCsReq, CmdID.CmdGetAllServerPrefsDataScRsp }, + .{ CmdID.CmdGetActivityScheduleConfigCsReq, CmdID.CmdGetActivityScheduleConfigScRsp }, + .{ CmdID.CmdGetMissionDataCsReq, CmdID.CmdGetMissionDataScRsp }, + .{ CmdID.CmdGetMissionEventDataCsReq, CmdID.CmdGetMissionEventDataScRsp }, + .{ CmdID.CmdGetQuestDataCsReq, CmdID.CmdGetQuestDataScRsp }, + .{ CmdID.CmdGetCurChallengeCsReq, CmdID.CmdGetCurChallengeScRsp }, + .{ CmdID.CmdGetRogueCommonDialogueDataCsReq, CmdID.CmdGetRogueCommonDialogueDataScRsp }, + .{ CmdID.CmdGetRogueInfoCsReq, CmdID.CmdGetRogueInfoScRsp }, + .{ CmdID.CmdGetRogueHandbookDataCsReq, CmdID.CmdGetRogueHandbookDataScRsp }, + .{ CmdID.CmdGetRogueEndlessActivityDataCsReq, CmdID.CmdGetRogueEndlessActivityDataScRsp }, + .{ CmdID.CmdChessRogueQueryCsReq, CmdID.CmdChessRogueQueryScRsp }, + .{ CmdID.CmdRogueTournQueryCsReq, CmdID.CmdRogueTournQueryScRsp }, + .{ CmdID.CmdSyncClientResVersionCsReq, CmdID.CmdSyncClientResVersionScRsp }, + .{ CmdID.CmdDailyFirstMeetPamCsReq, CmdID.CmdDailyFirstMeetPamScRsp }, + .{ CmdID.CmdGetBattleCollegeDataCsReq, CmdID.CmdGetBattleCollegeDataScRsp }, + .{ CmdID.CmdGetNpcStatusCsReq, CmdID.CmdGetNpcStatusScRsp }, + .{ CmdID.CmdGetSecretKeyInfoCsReq, CmdID.CmdGetSecretKeyInfoScRsp }, + .{ CmdID.CmdGetHeartDialInfoCsReq, CmdID.CmdGetHeartDialInfoScRsp }, + .{ CmdID.CmdGetVideoVersionKeyCsReq, CmdID.CmdGetVideoVersionKeyScRsp }, + .{ CmdID.CmdGetCurBattleInfoCsReq, CmdID.CmdGetCurBattleInfoScRsp }, + .{ CmdID.CmdHeliobusActivityDataCsReq, CmdID.CmdHeliobusActivityDataScRsp }, + .{ CmdID.CmdGetEnteredSceneCsReq, CmdID.CmdGetEnteredSceneScRsp }, + .{ CmdID.CmdGetAetherDivideInfoCsReq, CmdID.CmdGetAetherDivideInfoScRsp }, + .{ CmdID.CmdGetMapRotationDataCsReq, CmdID.CmdGetMapRotationDataScRsp }, + .{ CmdID.CmdGetRogueCollectionCsReq, CmdID.CmdGetRogueCollectionScRsp }, + .{ CmdID.CmdGetRogueExhibitionCsReq, CmdID.CmdGetRogueExhibitionScRsp }, + .{ CmdID.CmdPlayerReturnInfoQueryCsReq, CmdID.CmdPlayerReturnInfoQueryScRsp }, + .{ CmdID.CmdPlayerLoginFinishCsReq, CmdID.CmdPlayerLoginFinishScRsp }, + .{ CmdID.CmdGetLevelRewardTakenListCsReq, CmdID.CmdGetLevelRewardTakenListScRsp }, + .{ CmdID.CmdGetMainMissionCustomValueCsReq, CmdID.CmdGetMainMissionCustomValueScRsp }, +}; + +pub fn handle(session: *Session, packet: *const Packet) !void { + var arena = ArenaAllocator.init(session.allocator); + defer arena.deinit(); + + const cmd_id: CmdID = @enumFromInt(packet.cmd_id); + + inline for (HandlerList) |handler| { + if (handler[0] == cmd_id) { + try handler[1](session, packet, arena.allocator()); + std.log.debug("packet {} was handled", .{cmd_id}); + return; + } + } + + inline for (DummyCmdList) |pair| { + if (pair[0] == cmd_id) { + try session.send_empty(pair[1]); + return; + } + } + + std.log.warn("packet {} was ignored", .{cmd_id}); +} diff --git a/gameserver/src/main.zig b/gameserver/src/main.zig new file mode 100644 index 0000000..1060b27 --- /dev/null +++ b/gameserver/src/main.zig @@ -0,0 +1,10 @@ +const std = @import("std"); +const network = @import("network.zig"); +const handlers = @import("handlers.zig"); + +pub fn main() !void { + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + const allocator = gpa.allocator(); + + try network.listen(allocator); +} diff --git a/gameserver/src/network.zig b/gameserver/src/network.zig new file mode 100644 index 0000000..c4b7403 --- /dev/null +++ b/gameserver/src/network.zig @@ -0,0 +1,36 @@ +const std = @import("std"); +const Session = @import("Session.zig"); +const Allocator = std.mem.Allocator; + +pub fn listen(allocator: Allocator) !void { + const addr = std.net.Address.parseIp4("0.0.0.0", 23301) catch unreachable; + var listener = try addr.listen(.{ + .kernel_backlog = 100, + .reuse_address = true, + }); + + std.log.info("server is listening at {}", .{listener.listen_address}); + + while (true) { + const conn = listener.accept() catch continue; + errdefer conn.stream.close(); + + const session = try allocator.create(Session); + session.* = Session.init(conn.address, conn.stream, allocator); + + const thread = try std.Thread.spawn(.{}, runSession, .{session}); + thread.detach(); + } +} + +fn runSession(s: *Session) void { + std.log.info("new connection from {}", .{s.address}); + + if (s.run()) |_| { + std.log.info("client from {} disconnected", .{s.address}); + } else |err| { + std.log.err("session disconnected with an error: {}", .{err}); + } + + s.allocator.destroy(s); +} diff --git a/gameserver/src/services/avatar.zig b/gameserver/src/services/avatar.zig new file mode 100644 index 0000000..63b445b --- /dev/null +++ b/gameserver/src/services/avatar.zig @@ -0,0 +1,31 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; + +const AllAvatars = [_]u32{ + 1001, 1002, 1003, 1004, 1005, 1006, 1008, 1009, 1013, 1101, 1102, 1103, 1104, 1105, 1106, 1107, + 1108, 1109, 1110, 1111, 1112, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, + 1212, 1213, 1214, 1215, 1217, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1312, + 1314, 1315, 1221, 1218, +}; + +pub fn onGetAvatarData(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.GetAvatarDataCsReq, allocator); + var rsp = protocol.GetAvatarDataScRsp.init(allocator); + + rsp.is_all = req.is_get_all; + + for (AllAvatars) |id| { + var avatar = protocol.Avatar.init(allocator); + avatar.base_avatar_id = id; + avatar.level = 80; + avatar.promotion = 6; + avatar.rank = 6; + try rsp.avatar_list.append(avatar); + } + + try session.send(CmdID.CmdGetAvatarDataScRsp, rsp); +} diff --git a/gameserver/src/services/battle.zig b/gameserver/src/services/battle.zig new file mode 100644 index 0000000..3cee4e3 --- /dev/null +++ b/gameserver/src/services/battle.zig @@ -0,0 +1,50 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; + +pub fn onStartCocoonStage(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.StartCocoonStageCsReq, allocator); + + var avatar = protocol.BattleAvatar.init(allocator); + avatar.id = 1221; + avatar.hp = 10000; + avatar.sp = .{ .sp_cur = 10000, .sp_need = 10000 }; + avatar.level = 80; + avatar.rank = 6; + avatar.promotion = 6; + avatar.avatar_type = .AVATAR_FORMAL_TYPE; + + var battle = protocol.SceneBattleInfo.init(allocator); + for (0..req.wave) |_| { + const monster = protocol.SceneMonsterInfo{ .monster_id = 3024020 }; + var monster_wave = protocol.SceneMonsterWave.init(allocator); + try monster_wave.monster_list.append(monster); + try battle.monster_wave_list.append(monster_wave); + } + + try battle.battle_avatar_list.append(avatar); + battle.battle_id = 1; + battle.stage_id = 201012311; + battle.logic_random_seed = @intCast(@mod(std.time.timestamp(), 0xFFFFFFFF)); + + try session.send(CmdID.CmdStartCocoonStageScRsp, protocol.StartCocoonStageScRsp{ + .retcode = 0, + .cocoon_id = req.cocoon_id, + .prop_entity_id = req.prop_entity_id, + .wave = req.wave, + .battle_info = battle, + }); +} + +pub fn onPVEBattleResult(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.PVEBattleResultCsReq, allocator); + + var rsp = protocol.PVEBattleResultScRsp.init(allocator); + rsp.battle_id = req.battle_id; + rsp.end_status = req.end_status; + + try session.send(CmdID.CmdPVEBattleResultScRsp, rsp); +} diff --git a/gameserver/src/services/lineup.zig b/gameserver/src/services/lineup.zig new file mode 100644 index 0000000..613850f --- /dev/null +++ b/gameserver/src/services/lineup.zig @@ -0,0 +1,26 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; + +pub fn onGetCurLineupData(session: *Session, _: *const Packet, allocator: Allocator) !void { + const avatar = protocol.LineupAvatar{ + .id = 1221, + .slot = 0, + .satiety = 0, + .hp = 10000, + .avatar_type = protocol.AvatarType.AVATAR_FORMAL_TYPE, + .sp = .{ .sp_cur = 10000, .sp_need = 10000 }, + }; + + var lineup = protocol.LineupInfo.init(allocator); + lineup.name = .{ .Const = "Squad 1" }; + try lineup.avatar_list.append(avatar); + + try session.send(CmdID.CmdGetCurLineupDataScRsp, protocol.GetCurLineupDataScRsp{ + .retcode = 0, + .lineup = lineup, + }); +} diff --git a/gameserver/src/services/login.zig b/gameserver/src/services/login.zig new file mode 100644 index 0000000..02c8504 --- /dev/null +++ b/gameserver/src/services/login.zig @@ -0,0 +1,32 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; + +pub fn onPlayerGetToken(session: *Session, _: *const Packet, allocator: Allocator) !void { + var rsp = protocol.PlayerGetTokenScRsp.init(allocator); + + rsp.retcode = 0; + rsp.uid = 1337; + + try session.send(CmdID.CmdPlayerGetTokenScRsp, rsp); +} + +pub fn onPlayerLogin(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.PlayerLoginCsReq, allocator); + + var basic_info = protocol.PlayerBasicInfo.init(allocator); + basic_info.stamina = 240; + basic_info.level = 5; + basic_info.nickname = .{ .Const = "xeondev" }; + + var rsp = protocol.PlayerLoginScRsp.init(allocator); + rsp.retcode = 0; + rsp.login_random = req.login_random; + rsp.stamina = 240; + rsp.basic_info = basic_info; + + try session.send(CmdID.CmdPlayerLoginScRsp, rsp); +} diff --git a/gameserver/src/services/misc.zig b/gameserver/src/services/misc.zig new file mode 100644 index 0000000..314843a --- /dev/null +++ b/gameserver/src/services/misc.zig @@ -0,0 +1,26 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; +const B64Decoder = std.base64.standard.Decoder; + +pub fn onPlayerHeartBeat(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.PlayerHeartBeatCsReq, allocator); + + const downloadDataBin = "CDMQuQoa1AFDUy5Vbml0eUVuZ2luZS5HYW1lT2JqZWN0LkZpbmQoIlVJUm9vdC9BYm92ZURpYWxvZy9CZXRhSGludERpYWxvZyhDbG9uZSkiKTpHZXRDb21wb25lbnRJbkNoaWxkcmVuKHR5cGVvZihDUy5SUEcuQ2xpZW50LkxvY2FsaXplZFRleHQpKS50ZXh0ID0gIll1bmxpU1IgaXMgYSBmcmVlIGFuZCBvcGVuIHNvdXJjZSBzb2Z0d2FyZS4gZGlzY29yZC5nZy9yZXZlcnNlZHJvb21zIg=="; + const size = try B64Decoder.calcSizeForSlice(downloadDataBin); + const buf = try allocator.alloc(u8, size); + _ = try B64Decoder.decode(buf, downloadDataBin); + const data = try protocol.ClientDownloadData.decode(buf, allocator); + + const rsp = protocol.PlayerHeartBeatScRsp{ + .retcode = 0, + .client_time_ms = req.client_time_ms, + .server_time_ms = @intCast(std.time.timestamp()), + .download_data = data, + }; + + try session.send(CmdID.CmdPlayerHeartBeatScRsp, rsp); +} diff --git a/gameserver/src/services/mission.zig b/gameserver/src/services/mission.zig new file mode 100644 index 0000000..01ce24b --- /dev/null +++ b/gameserver/src/services/mission.zig @@ -0,0 +1,96 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; + +const FinishedMainMissionIdList = [_]u32{ + 1000101, 1000111, 1000112, 1000113, 1000114, 1000201, 1000202, 1000203, 1000204, 1000300, + 1000301, 1000302, 1000303, 1000304, 1000400, 1000401, 1000402, 1000410, 1000500, 1000501, + 1000502, 1000503, 1000504, 1000505, 1000510, 1000511, 1010001, 1010002, 1010101, 1010201, + 1010202, 1010203, 1010204, 1010205, 1010206, 1010301, 1010302, 1010303, 1010401, 1010405, + 1010402, 1010403, 1010500, 1010501, 1010502, 1010503, 1010601, 1010602, 1010700, 1010701, + 1010801, 1010802, 1010901, 1010902, 1011001, 1011002, 1011003, 1011100, 1011101, 1011102, + 1011103, 1011201, 1011202, 1011301, 1011400, 1011401, 1011402, 1011403, 1011501, 1011502, + 1011503, 1020101, 1020201, 1020302, 1020301, 1020400, 1020401, 1020402, 1020403, 1020501, + 1020601, 1020701, 1020702, 1020801, 1020901, 1021001, 1021101, 1021201, 1021301, 1021401, + 1021501, 1021601, 2000001, 2000002, 2000003, 2000004, 2000100, 2000101, 2000131, 2000132, + 2000133, 2000110, 2000111, 2000301, 2000103, 2000112, 2000108, 2000104, 2000102, 2000105, + 2000106, 2000107, 2000313, 2000314, 2000109, 2000113, 2000116, 2000118, 2000119, 2000120, + 2000122, 2000302, 2000303, 2000304, 2000305, 2000310, 2000311, 2000312, 2000320, 2000701, + 2000702, 2000703, 2000704, 2000705, 2000706, 2000707, 2010005, 2010301, 2010302, 2011103, + 2011104, 2011409, 2010401, 2010402, 2010405, 2010502, 2010503, 2010701, 2010708, 2010709, + 2010720, 2010730, 2010731, 2010732, 2010733, 2010734, 2010735, 2010904, 2011101, 2011102, + 2011105, 2011301, 2011302, 2011303, 2011501, 2011502, 2010909, 2010910, 2011901, 2011902, + 2011903, 2011904, 2011905, 2011906, 2020301, 2020302, 2020304, 2020316, 2020317, 2020318, + 2020319, 2020401, 2020402, 2020403, 2020404, 2020405, 2020406, 2020407, 2020303, 2020103, + 2020104, 2020105, 2020106, 2020107, 2020108, 2020109, 2020110, 2020201, 2020202, 2020203, + 2020204, 2000201, 2000202, 2000203, 2000204, 2000205, 2000206, 2000207, 2000208, 2000209, + 2000211, 2000212, 2010500, 2010501, 2010705, 2010706, 2010901, 2010902, 2010903, 2010702, + 2010703, 2011400, 2011401, 2011406, 2011402, 2011403, 2011404, 2011405, 2011407, 2011408, + 2011410, 2010905, 2010906, 2010907, 2010908, 2010911, 2010912, 2020305, 2020306, 2020309, + 2020307, 2020308, 2020701, 2020702, 2020313, 2020314, 2020315, 6020101, 6020201, 6020202, + 2020801, 2020802, 2020901, 2021601, 2021602, 3000201, 3000202, 3000203, 3000211, 3000212, + 3000213, 3000301, 3000302, 3000303, 3000522, 3000523, 3000524, 3000525, 3000526, 3000527, + 3000601, 3000602, 3000603, 3000604, 3000701, 3000702, 3000703, 3000704, 3000705, 3000800, + 3000801, 3000802, 3000803, 3010102, 3010103, 3010104, 3010105, 3010201, 3010202, 3010203, + 3010204, 3010205, 3011011, 3011012, 3011013, 3011014, 3011111, 3011112, 3011113, 3011114, + 3011201, 3011202, 3011203, 3011204, 3011205, 3011206, 3011207, 3011208, 3011401, 3011402, + 3011403, 3011404, 3011405, 3011406, 3011407, 3011408, 3011501, 3011502, 3011503, 3011504, + 3011505, 3011601, 3011602, 3011603, 3011604, 3011605, 3011606, 3011607, 3011608, 3011609, + 3011610, 3012001, 4020101, 4020102, 4020103, 4020104, 4020105, 4020106, 4020107, 4020108, + 4020109, 4020110, 4020111, 4020112, 4020113, 4020114, 4010105, 4010106, 4010107, 4010112, + 4010113, 4010131, 4010115, 4010116, 4010121, 4010122, 4010123, 4010124, 4010125, 4010126, + 4010127, 4010128, 4010133, 4010134, 4010135, 4010130, 4010136, 4010137, 4015101, 4015103, + 4015102, 4015202, 4015203, 4015204, 4015301, 4015302, 4015303, 4030001, 4030002, 4030003, + 4030004, 4030006, 4030007, 4030009, 4030010, 4040001, 4040002, 4040003, 4040004, 4040005, + 4040006, 4040052, 4040007, 4040008, 4040051, 4040009, 4040010, 4040011, 4040012, 4040053, + 4040014, 4040015, 4040017, 4040018, 4040019, 4040020, 4040021, 4040022, 4040023, 4040024, + 4040100, 4040189, 4040190, 4040101, 4040151, 4040154, 4040102, 4040103, 4040153, 4040104, + 4040152, 4040105, 4040106, 4040155, 4040107, 4040108, 4040109, 4040156, 4040157, 4040110, + 4040114, 4040115, 4040158, 4040159, 4040160, 4040161, 4040162, 4040116, 4040169, 4040163, + 4040164, 4040165, 4040166, 4040167, 4040168, 4040170, 4040171, 4040172, 4040173, 4040174, + 4040175, 4040176, 4040177, 4040178, 4040179, 4040180, 4040181, 4040182, 4040183, 4040184, + 4040185, 4040186, 4040117, 4040118, 4040119, 4040187, 4040120, 4040188, 4040121, 4040122, + 4040123, 4040124, 4040125, 4040126, 4040127, 4040128, 4040129, 4040130, 4040201, 4040202, + 4040203, 4040204, 4040205, 4040206, 4040207, 4040208, 4040290, 4040209, 4040210, 4040211, + 4040212, 4040213, 4040214, 4040215, 4040216, 4040217, 4040218, 4040219, 4040220, 4040221, + 4040222, 4040223, 4040224, 4040225, 4040226, 4040227, 4040228, 4040229, 4040230, 4040231, + 4040240, 4040241, 4040242, 4040244, 4040245, 4040246, 4040247, 4050005, 4050007, 4050008, + 4050009, 4050010, 4050011, 4050012, 4050013, 4050014, 4050015, 4050016, 4050017, 4050018, + 4050019, 4050020, 4050021, 4050022, 4050023, 4050024, 4050025, 4050026, 4050027, 4050028, + 4050029, 4050030, 4050031, 4050032, 4050033, 4050034, 4050035, 4050036, 4050037, 4072121, + 4072122, 4072123, 4071311, 4071312, 4071313, 4071320, 4071321, 4071322, 4122100, 4122101, + 4122102, 4122103, 4081311, 4081312, 4081313, 4081314, 4081315, 4081316, 4081317, 4081318, + 8000001, 8000002, 8000101, 8000102, 8000104, 8000105, 8000131, 8000132, 8000133, 8000134, + 8000135, 8000136, 8000137, 8000138, 8000139, 8000151, 8000152, 8000153, 8000154, 8000155, + 8000156, 8000157, 8000158, 8000159, 8000161, 8000162, 8000170, 8000171, 8000172, 8000173, + 8000174, 8000175, 8000177, 8000178, 8000180, 8000181, 8000183, 8000182, 8000185, 8000184, + 8000186, 8000187, 8000188, 8000189, 8000201, 8000202, 8000203, 8000204, 8001201, 8001202, + 8001203, 8001205, 8001206, 8001207, 8001208, 8001209, 8001211, 8001212, 8001213, 8001215, + 8001216, 8001219, 8001220, 8001223, 8001224, 8001225, 8001226, 8001227, 8001204, 8001210, + 8001214, 8001217, 8001218, 8001221, 8001222, 8001241, 8001242, 8001243, 8001244, 8001251, + 8001252, 8001253, 8001254, 8001255, 8001261, 8001262, 8001263, 8001264, 8001265, 8001266, + 8001267, 8001268, 8011401, 8002201, 8002202, 8002211, 8002212, 8002213, 8002214, 8002221, + 8002222, 8002231, 8002232, 8002233, 8002234, 8012101, 8012102, 8012103, 8012104, 8012105, + 8012106, 8012107, 8012401, 9999920, +}; + +pub fn onGetMissionStatus(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.GetMissionStatusCsReq, allocator); + var rsp = protocol.GetMissionStatusScRsp.init(allocator); + + rsp.retcode = 0; + for (req.sub_mission_id_list.items) |id| { + try rsp.sub_mission_status_list.append(protocol.Mission{ .id = id, .status = protocol.MissionStatus.MISSION_FINISH, .progress = 1 }); + } + + for (req.mission_event_id_list.items) |id| { + try rsp.mission_event_status_list.append(protocol.Mission{ .id = id, .status = protocol.MissionStatus.MISSION_FINISH, .progress = 1 }); + } + + try rsp.finished_main_mission_id_list.appendSlice(&FinishedMainMissionIdList); + + try session.send(CmdID.CmdGetMissionStatusScRsp, rsp); +} diff --git a/gameserver/src/services/scene.zig b/gameserver/src/services/scene.zig new file mode 100644 index 0000000..2f820ce --- /dev/null +++ b/gameserver/src/services/scene.zig @@ -0,0 +1,76 @@ +const std = @import("std"); +const protocol = @import("protocol"); +const CmdID = protocol.CmdID; +const Session = @import("../Session.zig"); +const Packet = @import("../Packet.zig"); +const Allocator = std.mem.Allocator; + +pub fn onGetCurSceneInfo(session: *Session, _: *const Packet, allocator: Allocator) !void { + var scene_info = protocol.SceneInfo.init(allocator); + scene_info.game_mode_type = 1; + scene_info.plane_id = 20101; + scene_info.floor_id = 20101001; + scene_info.entry_id = 2010101; + + { // Character + var scene_group = protocol.SceneGroupInfo.init(allocator); + scene_group.state = 1; + + try scene_group.entity_list.append(.{ + .entity = .{ + .actor = .{ + .base_avatar_id = 1221, + .avatar_type = .AVATAR_FORMAL_TYPE, + .uid = 1337, + .map_layer = 2, + }, + }, + .motion = .{ .pos = .{ .x = -2300, .y = 19365, .z = 3150 }, .rot = .{} }, + }); + + try scene_info.scene_group_list.append(scene_group); + } + + { // Calyx prop + var scene_group = protocol.SceneGroupInfo.init(allocator); + scene_group.state = 1; + scene_group.group_id = 19; + + var prop = protocol.ScenePropInfo.init(allocator); + prop.prop_id = 808; + prop.prop_state = 1; + + try scene_group.entity_list.append(.{ + .group_id = 19, + .inst_id = 300001, + .entity_id = 1337, + .entity = .{ + .prop = prop, + }, + .motion = .{ .pos = .{ .x = -570, .y = 19364, .z = 4480 }, .rot = .{} }, + }); + + try scene_info.scene_group_list.append(scene_group); + } + + try session.send(CmdID.CmdGetCurSceneInfoScRsp, protocol.GetCurSceneInfoScRsp{ + .scene = scene_info, + .retcode = 0, + }); +} + +pub fn onSceneEntityMove(session: *Session, packet: *const Packet, allocator: Allocator) !void { + const req = try packet.getProto(protocol.SceneEntityMoveCsReq, allocator); + + for (req.entity_motion_list.items) |entity_motion| { + if (entity_motion.motion) |motion| { + std.log.debug("[POSITION] entity_id: {}, motion: {}", .{ entity_motion.entity_id, motion }); + } + } + + try session.send(CmdID.CmdSceneEntityMoveScRsp, protocol.SceneEntityMoveScRsp{ + .retcode = 0, + .entity_motion_list = req.entity_motion_list, + .download_data = null, + }); +} diff --git a/protocol/build.zig b/protocol/build.zig new file mode 100644 index 0000000..1cc8b1e --- /dev/null +++ b/protocol/build.zig @@ -0,0 +1,18 @@ +const std = @import("std"); +const protobuf = @import("protobuf"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const protobuf_dep = b.dependency("protobuf", .{ + .optimize = optimize, + .target = target, + }); + + const protocol = b.addModule("protocol", .{ + .root_source_file = b.path("src/root.zig"), + }); + // + protocol.addImport("protobuf", protobuf_dep.module("protobuf")); +} diff --git a/protocol/build.zig.zon b/protocol/build.zig.zon new file mode 100644 index 0000000..2ec6956 --- /dev/null +++ b/protocol/build.zig.zon @@ -0,0 +1,15 @@ +.{ + .name = "protocol", + .version = "0.0.0", + .dependencies = .{ + .protobuf = .{ + .url = "https://github.com/Arwalk/zig-protobuf/archive/7c49ed66e029c9c7e6253b3d6d256118745550a4.tar.gz", + .hash = "122063ee7ff32a3c1aefd91a46a9fc23df0571949c3a02e2f44d39afbad0b53018a3", + }, + }, + .paths = .{ + "build.zig", + "build.zig.zon", + "src", + }, +} diff --git a/protocol/src/protocol.pb.zig b/protocol/src/protocol.pb.zig new file mode 100644 index 0000000..cda6b9f --- /dev/null +++ b/protocol/src/protocol.pb.zig @@ -0,0 +1,36306 @@ +// Code generated by protoc-gen-zig +///! package protocol +const std = @import("std"); +const Allocator = std.mem.Allocator; +const ArrayList = std.ArrayList; + +const protobuf = @import("protobuf"); +const ManagedString = protobuf.ManagedString; +const fd = protobuf.fd; + +pub const AvatarSlotType = enum(i32) { + AVATAR_SLOT_1 = 0, + AVATAR_SLOT_2 = 1, + AVATAR_SLOT_3 = 2, + _, +}; + +pub const ItemType = enum(i32) { + ITEM_TYPE_NONE = 0, + ITEM_AVATAR_CARD = 1, + ITEM_EQUIPMENT = 2, + ITEM_MATERIAL = 3, + ITEM_AVATAR_EXP = 4, + ITEM_RELIC = 5, + _, +}; + +pub const VirtualItemType = enum(i32) { + VIRTUAL_ITEM_NONE = 0, + VIRTUAL_ITEM_HCOIN = 1, + VIRTUAL_ITEM_SCOIN = 2, + VIRTUAL_ITEM_MCOIN = 3, + VIRTUAL_ITEM_STAMINA = 11, + VIRTUAL_ITEM_RESERVE_STAMINA = 12, + VIRTUAL_ITEM_AVATAR_EXP = 21, + VIRTUAL_ITEM_EXP = 22, + VIRTUAL_ITEM_DAILY_ACTIVE_POINT = 23, + VIRTUAL_ITEM_MP_MAX = 24, + VIRTUAL_ITEM_PLAYER_RETURN_POINT = 25, + VIRTUAL_ITEM_BATTLE_COLLEGE_POINT = 26, + VIRTUAL_ITEM_ROGUE_COIN = 31, + VIRTUAL_ITEM_ROGUE_TALENT_COIN = 32, + VIRTUAL_ITEM_ROGUE_REWARD_KEY = 33, + VIRTUAL_ITEM_ACHIEVEMENT_EXP = 41, + VIRTUAL_ITEM_BP_EXP = 51, + VIRTUAL_ITEM_BP_REAL_EXP = 52, + VIRTUAL_ITEM_MUSEUM_FUNDS = 53, + VIRTUAL_ITEM_WARRIOR_EXP = 190, + VIRTUAL_ITEM_ROGUE_EXP = 191, + VIRTUAL_ITEM_MAGE_EXP = 192, + VIRTUAL_ITEM_SHAMAN_EXP = 193, + VIRTUAL_ITEM_WARLOCK_EXP = 194, + VIRTUAL_ITEM_KNIGHT_EXP = 195, + VIRTUAL_ITEM_PRIEST_EXP = 196, + VIRTUAL_ITEM_PUNK_LORD_POINT = 100000, + VIRTUAL_ITEM_GAMEPLAY_COUNTER_MONSTER_SNEAK_VISION = 280001, + VIRTUAL_ITEM_GAMEPLAY_COUNTER_WOLF_BRO_BULLET = 280002, + VIRTUAL_ITEM_ALLEY_FUNDS = 281001, + VIRTUAL_ITEM_ROGUE_PUMAN_COUPON = 281012, + VIRTUAL_ITEM_MONTH_CARD = 300101, + VIRTUAL_ITEM_BP_NORMAL = 300102, + VIRTUAL_ITEM_BP_DELUXE = 300103, + VIRTUAL_ITEM_BP_UPGRADE = 300104, + VIRTUAL_ITEM_HELIOBUS_FANS = 281002, + VIRTUAL_ITEM_SPACE_ZOO_HYBRID_ITEM = 281003, + VIRTUAL_ITEM_SPACE_ZOO_EXP_POINT = 281004, + VIRTUAL_ITEM_ROGUE_NOUS_TALENT_COIN = 281013, + VIRTUAL_ITEM_EVOLVE_BUILD_COIN = 281019, + VIRTUAL_ITEM_DRINK_MAKER_TIP = 281005, + VIRTUAL_ITEM_MONOPOLY_DICE = 281014, + VIRTUAL_ITEM_MONOPOLY_COIN = 281015, + VIRTUAL_ITEM_MONOPOLY_CHEATDICE = 281016, + VIRTUAL_ITEM_MONOPOLY_REROLL = 281017, + VIRTUAL_ITEM_ROGUE_TOURN_PERMANENT_TALENT_COIN = 281018, + VIRTUAL_ITEM_ROGUE_TOURN_EXP = 281022, + VIRTUAL_ITEM_MATCHTHREE_COIN = 281024, + VIRTUAL_ITEM_SWORD_TRAINING_SKILL_POINT = 281023, + _, +}; + +pub const GameplayCounterType = enum(i32) { + GAMEPLAY_COUNTER_NONE = 0, + GAMEPLAY_COUNTER_MONSTER_SNEAK_VISION = 280001, + _, +}; + +pub const HEOAKAKGEBA = enum(i32) { + BLACK_LIMIT_LEVEL_ALL = 0, + _, +}; + +pub const AreaType = enum(i32) { + AREA_NONE = 0, + AREA_CN = 1, + AREA_JP = 2, + AREA_ASIA = 3, + AREA_WEST = 4, + AREA_KR = 5, + AREA_OVERSEAS = 6, + _, +}; + +pub const EntityType = enum(i32) { + ENTITY_NONE = 0, + ENTITY_AVATAR = 1, + ENTITY_MONSTER = 2, + ENTITY_NPC = 3, + ENTITY_PROP = 4, + ENTITY_TRIGGER = 5, + ENTITY_ENV = 6, + ENTITY_SUMMON_UNIT = 7, + _, +}; + +pub const LanguageType = enum(i32) { + LANGUAGE_NONE = 0, + LANGUAGE_SC = 1, + LANGUAGE_TC = 2, + LANGUAGE_EN = 3, + LANGUAGE_KR = 4, + LANGUAGE_JP = 5, + LANGUAGE_FR = 6, + LANGUAGE_DE = 7, + LANGUAGE_ES = 8, + LANGUAGE_PT = 9, + LANGUAGE_RU = 10, + LANGUAGE_TH = 11, + LANGUAGE_VI = 12, + LANGUAGE_ID = 13, + _, +}; + +pub const PlatformType = enum(i32) { + EDITOR = 0, + IOS = 1, + ANDROID = 2, + PC = 3, + WEB = 4, + WAP = 5, + PS4 = 6, + NINTENDO = 7, + CLOUD_ANDROID = 8, + CLOUD_PC = 9, + CLOUD_IOS = 10, + PS5 = 11, + MAC = 12, + CLOUD_MAC = 13, + CLOUD_WEB_ANDROID = 20, + CLOUD_WEB_IOS = 21, + CLOUD_WEB_PC = 22, + CLOUD_WEB_MAC = 23, + CLOUD_WEB_TOUCH = 24, + CLOUD_WEB_KEYBOARD = 25, + _, +}; + +pub const ReloginType = enum(i32) { + NO_KICK = 0, + FORCE_KICK = 1, + IDLE_KICK = 2, + SILENCE = 3, + _, +}; + +pub const AvatarType = enum(i32) { + AVATAR_TYPE_NONE = 0, + AVATAR_TRIAL_TYPE = 1, + AVATAR_LIMIT_TYPE = 2, + AVATAR_FORMAL_TYPE = 3, + AVATAR_ASSIST_TYPE = 4, + AVATAR_AETHER_DIVIDE_TYPE = 5, + AVATAR_UPGRADE_AVAILABLE_TYPE = 6, + _, +}; + +pub const MultiPathAvatarType = enum(i32) { + MultiPathAvatarTypeNone = 0, + Mar_7thKnightType = 1001, + Mar_7thRogueType = 1224, + BoyWarriorType = 8001, + GirlWarriorType = 8002, + BoyKnightType = 8003, + GirlKnightType = 8004, + BoyShamanType = 8005, + GirlShamanType = 8006, + _, +}; + +pub const Gender = enum(i32) { + GenderNone = 0, + GenderMan = 1, + GenderWoman = 2, + _, +}; + +pub const ProductType = enum(i32) { + PRODUCT_NONE = 0, + PRODUCT_NORMAL = 1, + PRODUCT_LIMIT = 2, + PRODUCT_LIMIT_NO_PAY = 3, + PRODUCT_NO_PROCESS_ORDER = 4, + _, +}; + +pub const ProductGiftType = enum(i32) { + PRODUCT_GIFT_NONE = 0, + PRODUCT_GIFT_COIN = 1, + PRODUCT_GIFT_MONTH_CARD = 2, + PRODUCT_GIFT_BP_68 = 3, + PRODUCT_GIFT_BP_128 = 4, + PRODUCT_GIFT_BP68_UPGRADE_128 = 5, + PRODUCT_GIFT_POINT_CARD = 6, + PRODUCT_GIFT_PS_PRE_ORDER_1 = 7, + PRODUCT_GIFT_PS_PRE_ORDER_2 = 8, + PRODUCT_GIFT_GOOGLE_POINTS_100 = 9, + PRODUCT_GIFT_GOOGLE_POINTS_150 = 10, + PRODUCT_GIFT_PS_POINT_CARD_030 = 11, + PRODUCT_GIFT_PS_POINT_CARD_050 = 12, + PRODUCT_GIFT_PS_POINT_CARD_100 = 13, + _, +}; + +pub const FeatureSwitchType = enum(i32) { + FEATURE_SWITCH_NONE = 0, + FEATURE_SWITCH_SHOP = 1, + FEATURE_SWITCH_LINEUP_NAME = 2, + FEATURE_SWITCH_RECHARGE_SHOP = 3, + FEATURE_SWITCH_NICKNAME = 4, + FEATURE_SWITCH_SIGNATURE = 5, + FEATURE_SWITCH_BATTLEPASS = 6, + FEATURE_SWITCH_PUNK_LORD = 7, + FEATURE_SWITCH_MONTHCARD_DAILY = 8, + FEATURE_SWITCH_PICTURE_SHARE = 9, + FEATURE_SWITCH_ROGUE = 10, + FEATURE_SWITCH_CHALLENGE = 11, + FEATURE_SWITCH_COCOON = 12, + FEATURE_SWITCH_RAID = 13, + FEATURE_SWITCH_MAZE_PLANE_EVENT = 14, + FEATURE_SWITCH_ACTIVITY_PANEL = 15, + FEATURE_SWITCH_MAILBOX = 16, + FEATURE_SWITCH_QUEST = 17, + FEATURE_SWITCH_GACHA = 18, + FEATURE_SWITCH_CHAT = 19, + FEATURE_SWITCH_MODIFY_FRIEND_ALIAS = 20, + FEATURE_SWITCH_USE_ITEM = 21, + FEATURE_SWITCH_ACTIVITY_SCHEDULE = 22, + FEATURE_SWITCH_FARM_ELEMENT = 23, + FEATURE_SWITCH_ACHIEVEMENT_LEVEL = 24, + FEATURE_SWITCH_DAILY_ACTIVE_LEVEL = 25, + FEATURE_SWITCH_PLAYER_RETURN = 26, + FEATURE_SWITCH_FIRST_SET_NICKNAME = 27, + FEATURE_SWITCH_MAIN_MISSION_REWARD = 28, + FEATURE_SWITCH_SUB_MISSION_REWARD = 29, + FEATURE_SWITCH_PAM_MISSION = 30, + FEATURE_SWITCH_DAILY_MISSION = 31, + FEATURE_SWITCH_DESTROY_ITEM = 32, + FEATURE_SWITCH_CONSUME_ITEM_TURN = 33, + FEATURE_SWITCH_ROGUE_MODIFIER = 34, + FEATURE_SWITCH_CHESS_ROGUE = 35, + FEATURE_SWITCH_CHESS_ROGUE_BOARD = 36, + FEATURE_SWITCH_ROLL_SHOP = 37, + FEATURE_SWITCH_H5_RETURN = 38, + FEATURE_SWITCH_OFFERING = 39, + FEATURE_SWITCH_SERVER_RED_POINT = 40, + FEATURE_SWITCH_MONOPOLY_OPTION_RATIO = 41, + FEATURE_SWITCH_MONOPOLY_GET_RAFFLE_TICKET = 42, + FEATURE_SWITCH_MONOPOLY_TAKE_RAFFLE_REWARD = 43, + FEATURE_SWITCH_CHALLENGE_RECOMMEND_LINEUP = 44, + FEATURE_SWITCH_PSN_MEMBER_SHIP_CHECK = 45, + FEATURE_SWITCH_PLAYER_BOARD_DEVELOPMENT = 46, + FEATURE_SWITCH_PVP = 47, + FEATURE_SWITCH_ROGUE_MODE = 48, + FEATURE_SWITCH_ROGUE_TOURN_UGC = 49, + FEATURE_SWITCH_RELIC_FILTER_PLAN_NAME = 50, + FEATURE_SWITCH_MAZE_ITEM_USE_BUFF_DROP = 51, + _, +}; + +pub const SecretKeyType = enum(i32) { + SECRET_KEY_NONE = 0, + SECRET_KEY_SERVER_CHECK = 1, + SECRET_KEY_VIDEO = 2, + SECRET_KEY_BATTLE_TIME = 3, + _, +}; + +pub const ReplayType = enum(i32) { + REPLAY_TYPE_NONE = 0, + REPLAY_TYPE_PUNK_LORD = 1, + _, +}; + +pub const PunkLordShareType = enum(i32) { + PUNK_LORD_SHARE_TYPE_NONE = 0, + PUNK_LORD_SHARE_TYPE_FRIEND = 1, + PUNK_LORD_SHARE_TYPE_ALL = 2, + _, +}; + +pub const PunkLordAttackerStatus = enum(i32) { + PUNK_LORD_ATTACKER_STATUS_NONE = 0, + PUNK_LORD_ATTACKER_STATUS_ATTACKED = 1, + PUNK_LORD_ATTACKER_STATUS_ATTACKING = 2, + PUNK_LORD_ATTACKER_STATUS_ATTACKED_AND_ATTACKING = 3, + _, +}; + +pub const PunkLordMonsterInfoNotifyReason = enum(i32) { + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_NONE = 0, + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_ENTER_RAID = 1, + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_BATTLE_END = 2, + PUNK_LORD_MONSTER_INFO_NOTIFY_REASON_LEAVE_RAID = 3, + _, +}; + +pub const ChatType = enum(i32) { + CHAT_TYPE_NONE = 0, + CHAT_TYPE_PRIVATE = 1, + CHAT_TYPE_GROUP = 2, + _, +}; + +pub const MsgType = enum(i32) { + MSG_TYPE_NONE = 0, + MSG_TYPE_CUSTOM_TEXT = 1, + MSG_TYPE_EMOJI = 2, + MSG_TYPE_INVITE = 3, + _, +}; + +pub const ShieldType = enum(i32) { + SHIELD_TYPE_NONE = 0, + SHIELD_TYPE_REPLACE = 1, + SHIELD_TYPE_SHIED = 2, + _, +}; + +pub const FuncUnlockId = enum(i32) { + FUNC_UNLOCK_ID_NONE = 0, + FUNC_UNLOCK_ID_RELIC = 403, + FUNC_UNLOCK_ID_RELIC_NUM = 404, + FUNC_UNLOCK_ID_EQUIPMENT = 401, + FUNC_UNLOCK_ID_SKILLTREE = 402, + FUNC_UNLOCK_ID_GACHA = 2300, + FUNC_UNLOCK_ID_EXPEDITION = 3100, + FUNC_UNLOCK_ID_COMPOSE = 4100, + FUNC_UNLOCK_ID_FIGHTACTIVITY = 3700, + _, +}; + +pub const AssistAvatarType = enum(i32) { + ASSIST_AVATAR_UNKNOW = 0, + ASSIST_AVATAR_LEVEL = 1, + ASSIST_AVATAR_RANK = 2, + _, +}; + +pub const DevelopmentType = enum(i32) { + DEVELOPMENT_NONE = 0, + DEVELOPMENT_ROGUE_COSMOS = 1, + DEVELOPMENT_ROGUE_CHESS = 2, + DEVELOPMENT_ROGUE_CHESS_NOUS = 3, + DEVELOPMENT_MEMORY_CHALLENGE = 4, + DEVELOPMENT_STORY_CHALLENGE = 5, + DEVELOPMENT_UNLOCK_AVATAR = 6, + DEVELOPMENT_UNLOCK_EQUIPMENT = 7, + DEVELOPMENT_ACTIVITY_START = 8, + DEVELOPMENT_ACTIVITY_END = 9, + DEVELOPMENT_BOSS_CHALLENGE = 10, + DEVELOPMENT_ROGUE_TOURN = 11, + DEVELOPMENT_ROGUE_TOURN_WEEK = 12, + _, +}; + +pub const PlayingState = enum(i32) { + PLAYING_STATE_NONE = 0, + PLAYING_ROGUE_COSMOS = 1, + PLAYING_ROGUE_CHESS = 2, + PLAYING_ROGUE_CHESS_NOUS = 3, + PLAYING_CHALLENGE_MEMORY = 4, + PLAYING_CHALLENGE_STORY = 5, + PLAYING_CHALLENGE_BOSS = 6, + PLAYING_ROGUE_TOURN = 7, + _, +}; + +pub const MatchRoomCharacter = enum(i32) { + MatchRoomCharacter_None = 0, + MatchRoomCharacter_Leader = 1, + MatchRoomCharacter_Member = 2, + MatchRoomCharacter_Watcher = 3, + _, +}; + +pub const MatchRoomCharacterStatus = enum(i32) { + MatchRoomCharacterStatus_None = 0, + MatchRoomCharacterStatus_Idle = 1, + MatchRoomCharacterStatus_Operating = 2, + MatchRoomCharacterStatus_Ready = 3, + MatchRoomCharacterStatus_Fighting = 4, + MatchRoomCharacterStatus_Watching = 5, + _, +}; + +pub const BattleCheckStrategyType = enum(i32) { + BATTLE_CHECK_STRATEGY_IDENTICAL = 0, + BATTLE_CHECK_STRATEGY_SERVER = 1, + BATTLE_CHECK_STRATEGY_CLIENT = 2, + _, +}; + +pub const BattleCheckResultType = enum(i32) { + BATTLE_CHECK_RESULT_SUCC = 0, + BATTLE_CHECK_RESULT_FAIL = 1, + BATTLE_CHECK_RESULT_PASS = 2, + _, +}; + +pub const BattleModuleType = enum(i32) { + BATTLE_MODULE_MAZE = 0, + BATTLE_MODULE_CHALLENGE = 1, + BATTLE_MODULE_COCOON = 2, + BATTLE_MODULE_ROGUE = 3, + BATTLE_MODULE_CHALLENGE_ACTIVITY = 4, + BATTLE_MODULE_TRIAL_LEVEL = 5, + BATTLE_MODULE_AETHER_DIVIDE = 6, + _, +}; + +pub const BOKJGICLIPI = enum(i32) { + AETHERDIVIDE_SPIRIT_LINEUP_NONE = 0, + AETHERDIVIDE_SPIRIT_LINEUP_NORMAL = 1, + AETHERDIVIDE_SPIRIT_LINEUP_TRIAL = 2, + _, +}; + +pub const DNIINPIEMIG = enum(i32) { + BATTLE_TARGET_TYPE_NONE = 0, + BATTLE_TARGET_TYPE_SCORE = 1, + BATTLE_TARGET_TYPE_ACHIEVEMENT = 2, + BATTLE_TARGET_TYPE_RAID = 3, + BATTLE_TARGET_TYPE_CHALLENGE_SCORE = 4, + BATTLE_TARGET_TYPE_COMMON = 5, + _, +}; + +pub const DeathSource = enum(i32) { + UNKNOWN = 0, + KILLED_BY_OTHERS = 1, + KILLED_BY_SELF = 2, + ESCAPE = 3, + _, +}; + +pub const BattleTag = enum(i32) { + TAG_NONE = 0, + TAG_HIDE_NPC_MONSTER = 1, + _, +}; + +pub const DIKEHIIKNII = enum(i32) { + NORMAL_CREATE = 0, + FORM_CHANGE = 1, + _, +}; + +pub const BattleEndReason = enum(i32) { + BATTLE_END_REASON_NONE = 0, + BATTLE_END_REASON_ALL_DIE = 1, + BATTLE_END_REASON_TURN_LIMIT = 2, + _, +}; + +pub const JAPMFPGNPEF = enum(i32) { + BATTLE_STATICTIC_EVENT_NONE = 0, + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_ADD_EXPLORE = 1, + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_OPEN_GRID = 2, + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_PICKUP_ITEM = 3, + BATTLE_STATICTIC_EVENT_TREASURE_DUNGEON_USE_BUFF = 4, + BATTLE_STATICTIC_EVENT_TELEVISION_ACTIVITY_UPDATE_MAZE_BUFF_LAYER = 5, + _, +}; + +pub const BattleEndStatus = enum(i32) { + BATTLE_END_NONE = 0, + BATTLE_END_WIN = 1, + BATTLE_END_LOSE = 2, + BATTLE_END_QUIT = 3, + _, +}; + +pub const HCKIOAEMKEE = enum(i32) { + FIGHT_GAME_MODE_NONE = 0, + FIGHT_GAME_MODE_MATCH3 = 1, + _, +}; + +pub const HBENCPAFOHF = enum(i32) { + FIGHT_KICKOUT_UNKNOWN = 0, + FIGHT_KICKOUT_BLACK = 1, + FIGHT_KICKOUT_BY_GM = 2, + FIGHT_KICKOUT_TIMEOUT = 3, + FIGHT_KICKOUT_SESSION_RESET = 4, + _, +}; + +pub const CGDIIHJICCK = enum(i32) { + LobbyCharacter_None = 0, + LobbyCharacter_Leader = 1, + LobbyCharacter_Member = 2, + LobbyCharacter_Watcher = 3, + _, +}; + +pub const IGNGFHOJMIA = enum(i32) { + LobbyCharacterStatus_None = 0, + LobbyCharacterStatus_Idle = 1, + LobbyCharacterStatus_Operating = 2, + LobbyCharacterStatus_Ready = 3, + LobbyCharacterStatus_Fighting = 4, + LobbyCharacterStatus_Watching = 5, + LobbyCharacterStatus_Matching = 6, + _, +}; + +pub const FPFECCNFJJL = enum(i32) { + LobbyModifyType_None = 0, + LobbyModifyType_Idle = 1, + LobbyModifyType_Ready = 2, + LobbyModifyType_Operating = 3, + LobbyModifyType_CancelMatch = 4, + LobbyModifyType_Match = 5, + LobbyModifyType_QuitLobby = 6, + LobbyModifyType_KickOut = 7, + LobbyModifyType_TimeOut = 8, + LobbyModifyType_JoinLobby = 9, + LobbyModifyType_LobbyDismiss = 10, + LobbyModifyType_MatchTimeOut = 11, + LobbyModifyType_FightStart = 12, + LobbyModifyType_Logout = 13, + LobbyModifyType_FightEnd = 14, + LobbyModifyType_FightRoomDestroyInInit = 15, + _, +}; + +pub const DPEOFIMABAB = enum(i32) { + FIGHT_ROOM_DESTROY_REASON_NONE = 0, + FIGHT_ROOM_DESTROY_REASON_SVR_STOP = 1, + FIGHT_ROOM_DESTROY_REASON_GAME_END = 2, + _, +}; + +pub const PNDLEEJDNJG = enum(i32) { + MATCH3_FINISH_REASON_DEFAULT = 0, + MATCH3_FINISH_REASON_LEAVE = 1, + MATCH3_FINISH_REASON_DIE = 2, + MATCH3_FINISH_REASON_GAMEEND = 3, + MATCH3_FINISH_REASON_KICKOUT = 4, + _, +}; + +pub const BNHPKNKIHAL = enum(i32) { + MATCH_UNIT_TYPE_NONE = 0, + MATCH_UNIT_TYPE_NORMAL = 1, + MATCH_UNIT_TYPE_ROBOT = 2, + MATCH_UNIT_TYPE_GM = 3, + _, +}; + +pub const Retcode = enum(i32) { + RET_SUCC = 0, + RET_FAIL = 1, + RET_SERVER_INTERNAL_ERROR = 2, + RET_TIMEOUT = 3, + RET_REPEATED_REQ = 4, + RET_REQ_PARA_INVALID = 5, + RET_PLAYER_DATA_ERROR = 6, + RET_PLAYER_CLIENT_PAUSED = 7, + RET_FUNC_CHECK_FAILED = 8, + RET_FEATURE_SWITCH_CLOSED = 9, + RET_FREQ_OVER_LIMIT = 10, + RET_SYSTEM_BUSY = 11, + RET_PLAYER_NOT_ONLINE = 12, + RET_REPEATE_LOGIN = 1000, + RET_RETRY_LOGIN = 1001, + RET_WAIT_LOGIN = 1002, + RET_NOT_IN_WHITE_LIST = 1003, + RET_IN_BLACK_LIST = 1004, + RET_ACCOUNT_VERIFY_ERROR = 1005, + RET_ACCOUNT_PARA_ERROR = 1006, + RET_ANTI_ADDICT_LOGIN = 1007, + RET_CHECK_SUM_ERROR = 1008, + RET_REACH_MAX_PLAYER_NUM = 1009, + RET_ALREADY_REGISTERED = 1010, + RET_GENDER_ERROR = 1011, + SET_NICKNAME_RET_CALLBACK_PROCESSING = 1012, + RET_IN_GM_BIND_ACCESS = 1013, + RET_QUEST_REWARD_ALREADY_TAKEN = 1100, + RET_QUEST_NOT_ACCEPT = 1101, + RET_QUEST_NOT_FINISH = 1102, + RET_QUEST_STATUS_ERROR = 1103, + RET_ACHIEVEMENT_LEVEL_NOT_REACH = 1104, + RET_ACHIEVEMENT_LEVEL_ALREADY_TAKEN = 1105, + RET_AVATAR_NOT_EXIST = 1200, + RET_AVATAR_RES_EXP_NOT_ENOUGH = 1201, + RET_AVATAR_EXP_REACH_PROMOTION_LIMIT = 1202, + RET_AVATAR_REACH_MAX_PROMOTION = 1203, + RET_SKILLTREE_CONFIG_NOT_EXIST = 1204, + RET_SKILLTREE_ALREADY_UNLOCK = 1205, + RET_SKILLTREE_PRE_LOCKED = 1206, + RET_SKILLTREE_LEVEL_NOT_MEET = 1207, + RET_SKILLTREE_RANK_NOT_MEET = 1208, + RET_AVATAR_DRESS_NO_EQUIPMENT = 1209, + RET_AVATAR_EXP_ITEM_NOT_EXIST = 1210, + RET_SKILLTREE_POINT_LOCKED = 1211, + RET_SKILLTREE_POINT_LEVEL_UPGRADE_NOT_MATCH = 1212, + RET_SKILLTREE_POINT_LEVEL_REACH_MAX = 1213, + RET_WORLD_LEVEL_NOT_MEET = 1214, + RET_PLAYER_LEVEL_NOT_MEET = 1215, + RET_AVATAR_RANK_NOT_MATCH = 1216, + RET_AVATAR_RANK_REACH_MAX = 1217, + RET_HERO_BASIC_TYPE_NOT_MATCH = 1218, + RET_AVATAR_PROMOTION_NOT_MEET = 1219, + RET_PROMOTION_REWARD_CONFIG_NOT_EXIST = 1220, + RET_PROMOTION_REWARD_ALREADY_TAKEN = 1221, + RET_AVATAR_SKIN_ITEM_NOT_EXIST = 1222, + RET_AVATAR_SKIN_ALREADY_DRESSED = 1223, + RET_AVATAR_NOT_DRESS_SKIN = 1224, + RET_AVATAR_SKIN_NOT_MATCH_AVATAR = 1225, + RET_ITEM_NOT_EXIST = 1300, + RET_ITEM_COST_NOT_ENOUGH = 1301, + RET_ITEM_COST_TOO_MUCH = 1302, + RET_ITEM_NO_COST = 1303, + RET_ITEM_NOT_ENOUGH = 1304, + RET_ITEM_INVALID = 1305, + RET_ITEM_CONFIG_NOT_EXIST = 1306, + RET_SCOIN_NOT_ENOUGH = 1307, + RET_ITEM_REWARD_EXCEED_LIMIT = 1308, + RET_ITEM_INVALID_USE = 1309, + RET_ITEM_USE_CONFIG_NOT_EXIST = 1310, + RET_REWARD_CONFIG_NOT_EXIST = 1311, + RET_ITEM_EXCEED_LIMIT = 1312, + RET_ITEM_COUNT_INVALID = 1313, + RET_ITEM_USE_TARGET_TYPE_INVALID = 1314, + RET_ITEM_USE_SATIETY_FULL = 1315, + RET_ITEM_COMPOSE_NOT_EXIST = 1316, + RET_RELIC_COMPOSE_NOT_EXIST = 1317, + RET_ITEM_CAN_NOT_SELL = 1318, + RET_ITEM_SELL_EXCEDD_LIMIT = 1319, + RET_ITEM_NOT_IN_COST_LIST = 1320, + RET_ITEM_SPECIAL_COST_NOT_ENOUGH = 1321, + RET_ITEM_SPECIAL_COST_TOO_MUCH = 1322, + RET_ITEM_FORMULA_NOT_EXIST = 1323, + RET_ITEM_AUTO_GIFT_OPTIONAL_NOT_EXIST = 1324, + RET_RELIC_COMPOSE_RELIC_INVALID = 1325, + RET_RELIC_COMPOSE_MAIN_AFFIX_ID_INVALID = 1326, + RET_RELIC_COMPOSE_WRONG_FORMULA_TYPE = 1327, + RET_RELIC_COMPOSE_RELIC_NOT_EXIST = 1328, + RET_RELIC_COMPOSE_BLACK_GOLD_COUNT_INVALID = 1329, + RET_RELIC_COMPOSE_BLACK_GOLD_NOT_NEED = 1330, + RET_MONTH_CARD_CANNOT_USE = 1331, + RET_ITEM_REWARD_EXCEED_DISAPPEAR = 1332, + RET_ITEM_NEED_RECYCLE = 1333, + RET_ITEM_COMPOSE_EXCEED_LIMIT = 1334, + RET_ITEM_CAN_NOT_DESTROY = 1335, + RET_ITEM_ALREADY_MARK = 1336, + RET_ITEM_MARK_EXCEED_LIMIT = 1337, + RET_ITEM_NOT_MARK = 1338, + RET_ITEN_TURN_FOOD_NOT_SET = 1339, + RET_ITEM_TURN_FOOD_ALREADY_SET = 1340, + RET_ITEM_TURN_FOOD_CONSUME_TYPE_ERROR = 1341, + RET_ITEM_TURN_FOOD_SWITCH_ALREADY_OPEN = 1342, + RET_ITEM_TURN_FOOD_SWITCH_ALREADY_CLOSE = 1343, + RET_HCOIN_EXCHANGE_TOO_MUCH = 1344, + RET_ITEM_TURN_FOOD_SCENE_TYPE_ERROR = 1345, + RET_EQUIPMENT_ALREADY_DRESSED = 1350, + RET_EQUIPMENT_NOT_EXIST = 1351, + RET_EQUIPMENT_REACH_LEVEL_LIMIT = 1352, + RET_EQUIPMENT_CONSUME_SELF = 1353, + RET_EQUIPMENT_ALREADY_LOCKED = 1354, + RET_EQUIPMENT_ALREADY_UNLOCKED = 1355, + RET_EQUIPMENT_LOCKED = 1356, + RET_EQUIPMENT_SELECT_NUM_OVER_LIMIT = 1357, + RET_EQUIPMENT_RANK_UP_MUST_CONSUME_SAME_TID = 1358, + RET_EQUIPMENT_PROMOTION_REACH_MAX = 1359, + RET_EQUIPMENT_RANK_UP_REACH_MAX = 1360, + RET_EQUIPMENT_LEVEL_REACH_MAX = 1361, + RET_EQUIPMENT_EXCEED_LIMIT = 1362, + RET_RELIC_NOT_EXIST = 1363, + RET_RELIC_REACH_LEVEL_LIMIT = 1364, + RET_RELIC_CONSUME_SELF = 1365, + RET_RELIC_ALREADY_DRESSED = 1366, + RET_RELIC_LOCKED = 1367, + RET_RELIC_ALREADY_LOCKED = 1368, + RET_RELIC_ALREADY_UNLOCKED = 1369, + RET_RELIC_LEVEL_IS_NOT_ZERO = 1370, + RET_UNIQUE_ID_REPEATED = 1371, + RET_EQUIPMENT_LEVEL_NOT_MEET = 1372, + RET_EQUIPMENT_ITEM_NOT_IN_COST_LIST = 1373, + RET_EQUIPMENT_LEVEL_GREATER_THAN_ONE = 1374, + RET_EQUIPMENT_ALREADY_RANKED = 1375, + RET_RELIC_EXCEED_LIMIT = 1376, + RET_RELIC_ALREADY_DISCARDED = 1377, + RET_RELIC_ALREADY_UNDISCARDED = 1378, + RET_EQUIPMENT_BATCH_LOCK_TOO_FAST = 1379, + RET_RELIC_FILTER_PLAN_SLOT_EMPTY = 1380, + RET_RELIC_FILTER_PLAN_SLOT_ALREADY_USED = 1381, + RET_RELIC_FILTER_PLAN_SLOT_INDEX_INVALID = 1382, + RET_RELIC_FILTER_PLAN_NAME_UTF8_ERROR = 1383, + RET_RELIC_FILTER_PLAN_NAME_FORMAT_ERROR = 1384, + RET_RELIC_FILTER_PLAN_NO_CHANGE = 1385, + RET_LINEUP_INVALID_INDEX = 1400, + RET_LINEUP_INVALID_MEMBER_POS = 1401, + RET_LINEUP_SWAP_NOT_EXIST = 1402, + RET_LINEUP_AVATAR_ALREADY_IN = 1403, + RET_LINEUP_CREATE_AVATAR_ERROR = 1404, + RET_LINEUP_AVATAR_INIT_ERROR = 1405, + RET_LINEUP_NOT_EXIST = 1406, + RET_LINEUP_ONLY_ONE_MEMBER = 1407, + RET_LINEUP_SAME_LEADER_SLOT = 1408, + RET_LINEUP_NO_LEADER_SELECT = 1409, + RET_LINEUP_SWAP_SAME_SLOT = 1410, + RET_LINEUP_AVATAR_NOT_EXIST = 1411, + RET_LINEUP_TRIAL_AVATAR_CAN_NOT_QUIT = 1412, + RET_LINEUP_VIRTUAL_LINEUP_PLANE_NOT_MATCH = 1413, + RET_LINEUP_NOT_VALID_LEADER = 1414, + RET_LINEUP_SAME_INDEX = 1415, + RET_LINEUP_IS_EMPTY = 1416, + RET_LINEUP_NAME_FORMAT_ERROR = 1417, + RET_LINEUP_TYPE_NOT_MATCH = 1418, + RET_LINEUP_REPLACE_ALL_FAILED = 1419, + RET_LINEUP_NOT_ALLOW_EDIT = 1420, + RET_LINEUP_AVATAR_IS_ALIVE = 1421, + RET_LINEUP_ASSIST_HAS_ONLY_MEMBER = 1422, + RET_LINEUP_ASSIST_CANNOT_SWITCH = 1423, + RET_LINEUP_AVATAR_TYPE_INVALID = 1424, + RET_LINEUP_NAME_UTF8_ERROR = 1425, + RET_LINEUP_LEADER_LOCK = 1426, + RET_LINEUP_STORY_LINE_NOT_MATCH = 1427, + RET_LINEUP_AVATAR_LOCK = 1428, + RET_LINEUP_AVATAR_INVALID = 1429, + RET_LINEUP_AVATAR_ALREADY_INIT = 1430, + RET_LINEUP_LIMITED = 1431, + RET_MAIL_NOT_EXIST = 1700, + RET_MAIL_RANGE_INVALID = 1701, + RET_MAIL_MAIL_ID_INVALID = 1702, + RET_MAIL_NO_MAIL_TAKE_ATTACHMENT = 1703, + RET_MAIL_NO_MAIL_TO_DEL = 1704, + RET_MAIL_TYPE_INVALID = 1705, + RET_MAIL_PARA_INVALID = 1706, + RET_MAIL_ATTACHEMENT_INVALID = 1707, + RET_MAIL_TICKET_INVALID = 1708, + RET_MAIL_TICKET_REPEATED = 1709, + RET_STAGE_SETTLE_ERROR = 1800, + RET_STAGE_CONFIG_NOT_EXIST = 1801, + RET_STAGE_NOT_FOUND = 1802, + RET_STAGE_COCOON_PROP_NOT_VALID = 1804, + RET_STAGE_COCOON_WAVE_NOT_VALID = 1805, + RET_STAGE_PROP_ID_NOT_EQUAL = 1806, + RET_STAGE_COCOON_WAVE_OVER = 1807, + RET_STAGE_WEEK_COCOON_OVER_CNT = 1808, + RET_STAGE_COCOON_NOT_OPEN = 1809, + RET_STAGE_TRIAL_NOT_OPEN = 1810, + RET_STAGE_FARM_NOT_OPEN = 1811, + RET_STAGE_FARM_TYPE_ERROR = 1812, + RET_CHAPTER_LOCK = 1900, + RET_CHAPTER_CHALLENGE_NUM_NOT_ENOUGH = 1901, + RET_CHAPTER_REWARD_ID_NOT_EXIST = 1902, + RET_CHAPTER_REWARD_ALREADY_TAKEN = 1903, + RET_BATTLE_STAGE_NOT_MATCH = 2000, + RET_IN_BATTLE_NOW = 2001, + RET_BATTLE_CHEAT = 2002, + RET_BATTLE_FAIL = 2003, + RET_BATTLE_NO_LINEUP = 2004, + RET_BATTLE_LINEUP_EMPTY = 2005, + RET_BATTLE_VERSION_NOT_MATCH = 2006, + RET_BATTLE_QUIT_BY_SERVER = 2007, + RET_IN_BATTLE_CHECK = 2008, + RET_BATTLE_CHECK_NEED_RETRY = 2009, + RET_BATTLE_COST_TIME_CHECK_FAIL = 2010, + RET_LACK_EXCHANGE_STAMINA_TIMES = 2100, + RET_LACK_STAMINA = 2101, + RET_STAMINA_FULL = 2102, + RET_AUTHKEY_SIGN_TYPE_ERROR = 2103, + RET_AUTHKEY_SIGN_VER_ERROR = 2104, + RET_NICKNAME_FORMAT_ERROR = 2105, + RET_SENSITIVE_WORDS = 2106, + RET_LEVEL_REWARD_HAS_TAKEN = 2107, + RET_LEVEL_REWARD_LEVEL_ERROR = 2108, + RET_LANGUAGE_INVALID = 2109, + RET_NICKNAME_IN_CD = 2110, + RET_GAMEPLAY_BIRTHDAY_INVALID = 2111, + RET_GAMEPLAY_BIRTHDAY_ALREADY_SET = 2112, + RET_NICKNAME_UTF8_ERROR = 2113, + RET_NICKNAME_DIGIT_LIMIT_ERROR = 2114, + RET_SENSITIVE_WORDS_PLATFORM_ERROR = 2115, + RET_PLAYER_SETTING_TYPE_INVALID = 2116, + RET_MAZE_LACK_TICKET = 2201, + RET_MAZE_NOT_UNLOCK = 2202, + RET_MAZE_NO_ABILITY = 2204, + RET_MAZE_NO_PLANE = 2205, + RET_MAZE_MAP_NOT_EXIST = 2207, + RET_MAZE_MP_NOT_ENOUGH = 2213, + RET_SPRING_NOT_ENABLE = 2214, + RET_SPRING_TOO_FAR = 2216, + RET_NOT_IN_MAZE = 2218, + RET_MAZE_TIME_OF_DAY_TYPE_ERROR = 2223, + RET_SCENE_TRANSFER_LOCKED_BY_TASK = 2224, + RET_PLOT_NOT_UNLOCK = 2300, + RET_MISSION_NOT_EXIST = 2400, + RET_MISSION_ALREADY_DONE = 2401, + RET_DAILY_TASK_NOT_FINISH = 2402, + RET_DAILY_TASK_REWARD_HAS_TAKEN = 2403, + RET_MISSION_NOT_FINISH = 2404, + RET_MISSION_NOT_DOING = 2405, + RET_MISSION_FINISH_WAY_NOT_MATCH = 2406, + RET_MISSION_SCENE_NOT_MATCH = 2407, + RET_MISSION_CUSTOM_VALUE_NOT_VALID = 2408, + RET_MISSION_SUB_MISSION_NOT_MATCH = 2409, + RET_ADVENTURE_MAP_NOT_EXIST = 2500, + RET_SCENE_ENTITY_NOT_EXIST = 2600, + RET_NOT_IN_SCENE = 2601, + RET_SCENE_MONSTER_NOT_EXIST = 2602, + RET_INTERACT_CONFIG_NOT_EXIST = 2603, + RET_UNSUPPORTED_PROP_STATE = 2604, + RET_SCENE_ENTRY_ID_NOT_MATCH = 2605, + RET_SCENE_ENTITY_MOVE_CHECK_FAILED = 2606, + RET_ASSIST_MONSTER_COUNT_LIMIT = 2607, + RET_SCENE_USE_SKILL_FAIL = 2608, + RET_PROP_IS_HIDDEN = 2609, + RET_LOADING_SUCC_ALREADY = 2610, + RET_SCENE_ENTITY_TYPE_INVALID = 2611, + RET_INTERACT_TYPE_INVALID = 2612, + RET_INTERACT_NOT_IN_REGION = 2613, + RET_INTERACT_SUB_TYPE_INVALID = 2614, + RET_NOT_LEADER_ENTITY = 2615, + RET_MONSTER_IS_NOT_FARM_ELEMENT = 2616, + RET_MONSTER_CONFIG_NOT_EXIST = 2617, + RET_AVATAR_HP_ALREADY_FULL = 2618, + RET_CUR_INTERACT_ENTITY_NOT_MATCH = 2619, + RET_PLANE_TYPE_NOT_ALLOW = 2620, + RET_GROUP_NOT_EXIST = 2621, + RET_GROUP_SAVE_DATA_IN_CD = 2622, + RET_GROUP_SAVE_LENGH_REACH_MAX = 2623, + RET_RECENT_ELEMENT_NOT_EXIST = 2624, + RET_RECENT_ELEMENT_STAGE_NOT_MATCH = 2625, + RET_SCENE_POSITION_VERSION_NOT_MATCH = 2626, + RET_GAMEPLAY_COUNTER_NOT_EXIST = 2627, + RET_GAMEPLAY_COUNTER_NOT_ENOUGH = 2628, + RET_GROUP_STATE_NOT_MATCH = 2629, + RET_SCENE_ENTITY_POS_NOT_MATCH = 2630, + RET_GROUP_STATE_CUSTOM_SAVE_DATA_OFF = 2631, + RET_BUY_TIMES_LIMIT = 2700, + RET_BUY_LIMIT_TYPE = 2701, + RET_SHOP_NOT_OPEN = 2702, + RET_GOODS_NOT_OPEN = 2703, + RET_CITY_LEVEL_REWARD_TAKEN = 2704, + RET_CITY_LEVEL_NOT_MEET = 2705, + RET_SINGLE_BUY_LIMIT = 2706, + RET_TUTORIAL_NOT_UNLOCK = 2751, + RET_TUTORIAL_UNLOCK_ALREADY = 2752, + RET_TUTORIAL_FINISH_ALREADY = 2753, + RET_TUTORIAL_PRE_NOT_UNLOCK = 2754, + RET_TUTORIAL_PLAYER_LEVEL_NOT_MATCH = 2755, + RET_TUTORIAL_TUTORIAL_NOT_FOUND = 2756, + RET_CHALLENGE_NOT_EXIST = 2801, + RET_CHALLENGE_NOT_UNLOCK = 2802, + RET_CHALLENGE_ALREADY = 2803, + RET_CHALLENGE_LINEUP_EDIT_FORBIDDEN = 2804, + RET_CHALLENGE_LINEUP_EMPTY = 2805, + RET_CHALLENGE_NOT_DOING = 2806, + RET_CHALLENGE_NOT_FINISH = 2807, + RET_CHALLENGE_TARGET_NOT_FINISH = 2808, + RET_CHALLENGE_TARGET_REWARD_TAKEN = 2809, + RET_CHALLENGE_TIME_NOT_VALID = 2810, + RET_CHALLENGE_STARS_COUNT_NOT_MEET = 2811, + RET_CHALLENGE_STARS_REWARD_TAKEN = 2812, + RET_CHALLENGE_STARS_NOT_EXIST = 2813, + RET_CHALLENGE_CUR_SCENE_NOT_ENTRY_FLOOR = 2814, + RET_CHALLENGE_NO_TEAM_ARCHIVE = 2815, + RET_CHALLENGE_LINEUP_AVATAR_TYPE_INVALID = 2816, + RET_BASIC_TYPE_ALREADY = 2850, + RET_NO_BASIC_TYPE = 2851, + RET_NOT_CHOOSE_BASIC_TYPE = 2852, + RET_NOT_FUNC_CLOSE = 2853, + RET_NOT_CHOOSE_GENDER = 2854, + RET_NOT_REQ_UNLOCK_BASIC_TYPE = 2855, + RET_AVATAR_PATH_LOCKED = 2856, + RET_ROGUE_STATUS_NOT_MATCH = 2901, + RET_ROGUE_SELECT_BUFF_NOT_EXIST = 2902, + RET_ROGUE_COIN_NOT_ENOUGH = 2903, + RET_ROGUE_STAMINA_NOT_ENOUGH = 2904, + RET_ROGUE_APPRAISAL_COUNT_NOT_ENOUGH = 2905, + RET_ROGUE_PROP_ALREADY_USED = 2906, + RET_ROGUE_RECORD_ALREADY_SAVED = 2907, + RET_ROGUE_ROLL_BUFF_MAX_COUNT = 2908, + RET_ROGUE_PICK_AVATAR_INVALID = 2909, + RET_ROGUE_QUEST_EXPIRE = 2910, + RET_ROGUE_QUEST_REWARD_ALREADY = 2911, + RET_ROGUE_REVIVE_COUNT_NOT_ENOUGH = 2912, + RET_ROGUE_AREA_INVALID = 2913, + RET_ROGUE_SCORE_REWARD_POOL_INVALID = 2914, + RET_ROGUE_SCORE_REWARD_ROW_INVALID = 2915, + RET_ROGUE_AEON_LEVEL_NOT_MEET = 2916, + RET_ROGUE_AEON_LEVEL_REWARD_ALREADY_TAKEN = 2917, + RET_ROGUE_AEON_CONFIG_NOT_EXIST = 2918, + RET_ROGUE_TRIAL_AVATAR_INVALID = 2919, + RET_ROGUE_HANDBOOK_REWARD_ALREADY_TAKEN = 2920, + RET_ROGUE_ROOM_TYPE_NOT_MATCH = 2921, + RET_ROGUE_SHOP_GOOD_NOT_FOUND = 2922, + RET_ROGUE_SHOP_GOOD_ALREADY_BOUGHT = 2923, + RET_ROGUE_SHOP_GOOD_ALREADY_OWN = 2924, + RET_ROGUE_SHOP_MIRACLE_NOT_EXIST = 2925, + RET_ROGUE_SHOP_NOT_EXIST = 2926, + RET_ROGUE_SHOP_CANNOT_REFRESH = 2927, + RET_ROGUE_SELECT_BUFF_CERTAIN_MISMATCH = 2928, + RET_MISSION_EVENT_CONFIG_NOT_EXIST = 2951, + RET_MISSION_EVENT_NOT_CLIENT = 2952, + RET_MISSION_EVENT_FINISHED = 2953, + RET_MISSION_EVENT_DOING = 2954, + RET_HAS_CHALLENGE_MISSION_EVENT = 2955, + RET_NOT_CHALLENGE_MISSION_EVENT = 2956, + RET_GACHA_ID_NOT_EXIST = 3001, + RET_GACHA_NUM_INVALID = 3002, + RET_GACHA_FIRST_GACHA_MUST_ONE = 3003, + RET_GACHA_REQ_DUPLICATED = 3004, + RET_GACHA_NOT_IN_SCHEDULE = 3005, + RET_GACHA_NEWBIE_CLOSE = 3006, + RET_GACHA_TODAY_LIMITED = 3007, + RET_GACHA_NOT_SUPPORT = 3008, + RET_GACHA_CEILING_NOT_ENOUGH = 3009, + RET_GACHA_CEILING_CLOSE = 3010, + RET_NOT_IN_RAID = 3101, + RET_RAID_DOING = 3102, + RET_NOT_PROP = 3103, + RET_RAID_ID_NOT_MATCH = 3104, + RET_RAID_RESTART_NOT_MATCH = 3105, + RET_RAID_LIMIT = 3106, + RET_RAID_AVATAR_LIST_EMPTY = 3107, + RET_RAID_AVATAR_NOT_EXIST = 3108, + RET_CHALLENGE_RAID_REWARD_ALREADY = 3109, + RET_CHALLENGE_RAID_SCORE_NOT_REACH = 3110, + RET_CHALLENGE_RAID_NOT_OPEN = 3111, + RET_RAID_FINISHED = 3112, + RET_RAID_WORLD_LEVEL_NOT_LOCK = 3113, + RET_RAID_CANNOT_USE_ASSIST = 3114, + RET_RAID_AVATAR_NOT_MATCH = 3115, + RET_RAID_CAN_NOT_SAVE = 3116, + RET_RAID_NO_SAVE = 3117, + RET_ACTIVITY_RAID_NOT_OPEN = 3118, + RET_RAID_AVATAR_CAPTAIN_NOT_EXIST = 3119, + RET_RAID_STORY_LINE_NOT_MATCH = 3120, + RET_TALK_EVENT_ALREADY_TAKEN = 3151, + RET_NPC_ALREADY_MEET = 3152, + RET_NPC_NOT_IN_CONFIG = 3153, + RET_DIALOGUE_GROUP_DISMATCH = 3154, + RET_DIALOGUE_EVENT_INVALID = 3155, + RET_TALK_EVENT_TAKE_PROTO_NOT_MATCH = 3156, + RET_TALK_EVENT_NOT_VALID = 3157, + RET_EXPEDITION_CONFIG_NOT_EXIST = 3201, + RET_EXPEDITION_REWARD_CONFIG_NOT_EXIST = 3202, + RET_EXPEDITION_NOT_UNLOCKED = 3203, + RET_EXPEDITION_ALREADY_ACCEPTED = 3204, + RET_EXPEDITION_REPEATED_AVATAR = 3205, + RET_AVATAR_ALREADY_DISPATCHED = 3206, + RET_EXPEDITION_NOT_ACCEPTED = 3207, + RET_EXPEDITION_NOT_FINISH = 3208, + RET_EXPEDITION_ALREADY_FINISH = 3209, + RET_EXPEDITION_TEAM_COUNT_LIMIT = 3210, + RET_EXPEDITION_AVATAR_NUM_NOT_MATCH = 3211, + RET_EXPEDITION_NOT_OPEN = 3212, + RET_EXPEDITION_FRIEND_AVATAR_NOT_VALID = 3213, + RET_EXPEDITION_NOT_PUBLISHED = 3214, + RET_LOGIN_ACTIVITY_HAS_TAKEN = 3301, + RET_LOGIN_ACTIVITY_DAYS_LACK = 3302, + RET_TRIAL_ACTIVITY_REWARD_ALREADY_TAKE = 3303, + RET_TRIAL_ACTIVITY_STAGE_NOT_FINISH = 3304, + RET_MONSTER_RESEARCH_ACTIVITY_HAS_TAKEN = 3305, + RET_MONSTER_RESEARCH_ACTIVITY_MATERIAL_NOT_SUBMITTED = 3306, + RET_MONSTER_RESEARCH_ACTIVITY_MATERIAL_ALREADY_SUBMITTED = 3307, + RET_FANTASTIC_STORY_ACTIVITY_STORY_ERROR = 3308, + RET_FANTASTIC_STORY_ACTIVITY_STORY_NOT_OPEN = 3309, + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_ERROR = 3310, + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_NOT_OPEN = 3311, + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_AVATAR_ERROR = 3312, + RET_FANTASTIC_STORY_ACTIVITY_BATTLE_BUFF_ERROR = 3313, + RET_FANTASTIC_STORY_ACTIVITY_PRE_BATTLE_SCORE_NOT_ENOUGH = 3314, + RET_TRIAL_ACTIVITY_ALREADY_IN_TRIAL_ACTIVITY = 3315, + RET_COMMON_ACTIVITY_NOT_OPEN = 3316, + RET_MESSAGE_CONFIG_NOT_EXIST = 3501, + RET_MESSAGE_SECTION_NOT_TAKE = 3502, + RET_MESSAGE_GROUP_NOT_TAKE = 3503, + RET_MESSAGE_SECTION_ID_NOT_MATCH = 3504, + RET_MESSAGE_SECTION_CAN_NOT_FINISH = 3505, + RET_MESSAGE_ITEM_CAN_NOT_FINISH = 3506, + RET_MESSAGE_ITEM_RAID_CAN_NOT_FINISH = 3507, + RET_FRIEND_ALREADY_IS_FRIEND = 3601, + RET_FRIEND_IS_NOT_FRIEND = 3602, + RET_FRIEND_APPLY_EXPIRE = 3603, + RET_FRIEND_IN_BLACKLIST = 3604, + RET_FRIEND_NOT_IN_BLACKLIST = 3605, + RET_FRIEND_NUMBER_LIMIT = 3606, + RET_FRIEND_BLACKLIST_NUMBER_LIMIT = 3607, + RET_FRIEND_DAILY_APPLY_LIMIT = 3608, + RET_FRIEND_IN_HANDLE_LIMIT = 3609, + RET_FRIEND_APPLY_IN_CD = 3610, + RET_FRIEND_REMARK_NAME_FORMAT_ERROR = 3611, + RET_FRIEND_PLAYER_NOT_FOUND = 3612, + RET_FRIEND_IN_TARGET_BLACKLIST = 3613, + RET_FRIEND_TARGET_NUMBER_LIMIT = 3614, + RET_ASSIST_QUERY_TOO_FAST = 3615, + RET_ASSIST_NOT_EXIST = 3616, + RET_ASSIST_USED_ALREADY = 3617, + RET_FRIEND_REPORT_REASON_FORMAT_ERROR = 3618, + RET_FRIEND_REPORT_SENSITIVE_WORDS = 3619, + RET_ASSIST_USED_TIMES_OVER = 3620, + RET_ASSIST_QUIT_ALREADY = 3621, + RET_ASSIST_AVATAR_IN_LINEUP = 3622, + RET_ASSIST_NO_REWARD = 3623, + RET_FRIEND_SEARCH_NUM_LIMIT = 3624, + RET_FRIEND_SEARCH_IN_CD = 3625, + RET_FRIEND_REMARK_NAME_UTF8_ERROR = 3626, + RET_FRIEND_REPORT_REASON_UTF8_ERROR = 3627, + RET_ASSIST_SET_ALREADY = 3628, + RET_FRIEND_TARGET_FORBID_OTHER_APPLY = 3629, + RET_FRIEND_MARKED_CNT_MAX = 3630, + RET_FRIEND_MARKED_ALREADY = 3631, + RET_FRIEND_NOT_MARKED = 3632, + RET_FRIEND_CHALLENGE_LINEUP_RECOMMEND_IN_CD = 3633, + RET_VIEW_PLAYER_CARD_IN_CD = 3634, + RET_VIEW_PLAYER_BATTLE_RECORD_IN_CD = 3635, + RET_PLAYER_BOARD_HEAD_ICON_NOT_EXIST = 3701, + RET_PLAYER_BOARD_HEAD_ICON_LOCKED = 3702, + RET_PLAYER_BOARD_HEAD_ICON_ALREADY_UNLOCKED = 3703, + RET_PLAYER_BOARD_DISPLAY_AVATAR_NOT_EXIST = 3704, + RET_PLAYER_BOARD_DISPLAY_AVATAR_EXCEED_LIMIT = 3705, + RET_PLAYER_BOARD_DISPLAY_REPEATED_AVATAR = 3706, + RET_PLAYER_BOARD_DISPLAY_AVATAR_SAME_POS = 3707, + RET_PLAYER_BOARD_DISPLAY_AVATAR_LOCKED = 3708, + RET_SIGNATURE_LENGTH_EXCEED_LIMIT = 3709, + RET_SIGNATURE_SENSITIVE_WORDS = 3710, + RET_PLAYER_BOARD_ASSIST_AVATAR_NOT_EXIST = 3712, + RET_PLAYER_BOARD_ASSIST_AVATAR_LOCKED = 3713, + RET_SIGNATURE_UTF8_ERROR = 3714, + RET_PLAYER_BOARD_ASSIST_AVATAR_CNT_ERROR = 3715, + RET_BATTLE_PASS_TIER_NOT_VALID = 3801, + RET_BATTLE_PASS_LEVEL_NOT_MEET = 3802, + RET_BATTLE_PASS_REWARD_TAKE_ALREADY = 3803, + RET_BATTLE_PASS_NOT_PREMIUM = 3804, + RET_BATTLE_PASS_NOT_DOING = 3805, + RET_BATTLE_PASS_LEVEL_INVALID = 3806, + RET_BATTLE_PASS_NOT_UNLOCK = 3807, + RET_BATTLE_PASS_NO_REWARD = 3808, + RET_BATTLE_PASS_QUEST_NOT_VALID = 3809, + RET_BATTLE_PASS_NOT_CHOOSE_OPTIONAL = 3810, + RET_BATTLE_PASS_NOT_TAKE_REWARD = 3811, + RET_BATTLE_PASS_OPTIONAL_NOT_VALID = 3812, + RET_BATTLE_PASS_BUY_ALREADY = 3813, + RET_BATTLE_PASS_NEAR_END = 3814, + RET_MUSIC_LOCKED = 3901, + RET_MUSIC_NOT_EXIST = 3902, + RET_MUSIC_UNLOCK_FAILED = 3903, + RET_PUNK_LORD_LACK_SUMMON_TIMES = 4001, + RET_PUNK_LORD_ATTACKING_MONSTER_LIMIT = 4002, + RET_PUNK_LORD_MONSTER_NOT_EXIST = 4003, + RET_PUNK_LORD_MONSTER_ALREADY_SHARED = 4004, + RET_PUNK_LORD_MONSTER_EXPIRED = 4005, + RET_PUNK_LORD_SELF_MONSTER_ATTACK_LIMIT = 4006, + RET_PUNK_LORD_LACK_SUPPORT_TIMES = 4007, + RET_PUNK_LORD_MONSTER_ALREADY_KILLED = 4008, + RET_PUNK_LORD_MONSTER_ATTACKER_LIMIT = 4009, + RET_PUNK_LORD_WORLD_LEVLE_NOT_VALID = 4010, + RET_PUNK_LORD_REWARD_LEVLE_NOT_EXIST = 4011, + RET_PUNK_LORD_POINT_NOT_MEET = 4012, + RET_PUNK_LORD_IN_ATTACKING = 4013, + RET_PUNK_LORD_OPERATION_IN_CD = 4014, + RET_PUNK_LORD_REWARD_ALREADY_TAKEN = 4015, + RET_PUNK_LORD_OVER_BONUS_REWARD_LIMIT = 4016, + RET_PUNK_LORD_NOT_IN_SCHEDULE = 4017, + RET_PUNK_LORD_MONSTER_NOT_ATTACKED = 4018, + RET_PUNK_LORD_MONSTER_NOT_KILLED = 4019, + RET_PUNK_LORD_MONSTER_KILLED_SCORE_ALREADY_TAKE = 4020, + RET_PUNK_LORD_REWARD_LEVLE_ALREADY_TAKE = 4021, + RET_DAILY_ACTIVE_LEVEL_INVALID = 4101, + RET_DAILY_ACTIVE_LEVEL_REWARD_ALREADY_TAKEN = 4102, + RET_DAILY_ACTIVE_LEVEL_AP_NOT_ENOUGH = 4103, + RET_DAILY_MEET_PAM = 4201, + RET_REPLAY_ID_NOT_MATCH = 4251, + RET_REPLAY_REQ_NOT_VALID = 4252, + RET_FIGHT_ACTIVITY_DIFFICULTY_LEVEL_NOT_PASSED = 4301, + RET_FIGHT_ACTIVITY_DIFFICULTY_LEVEL_REWARD_ALREADY_TAKE = 4302, + RET_FIGHT_ACTIVITY_STAGE_NOT_OPEN = 4303, + RET_FIGHT_ACTIVITY_LEVEL_NOT_UNLOCK = 4304, + RET_TRAIN_VISITOR_VISITOR_NOT_EXIST = 4351, + RET_TRAIN_VISITOR_BEHAVIOR_NOT_EXIST = 4352, + RET_TRAIN_VISITOR_BEHAVIOR_FINISHED = 4353, + RET_TRAIN_VISITOR_ALL_BEHAVIOR_REWARD_TAKEN = 4354, + RET_TRAIN_VISITOR_GET_ON_MISSION_NOT_FINISH = 4355, + RET_TRAIN_VISITOR_NOT_GET_OFF = 4356, + RET_TEXT_JOIN_UNKNOW_IS_OVERRIDE = 4401, + RET_TEXT_JOIN_ID_NOT_EXIST = 4402, + RET_TEXT_JOIN_CAN_NOT_OVERRIDE = 4403, + RET_TEXT_JOIN_ITEM_ID_ERROR = 4404, + RET_TEXT_JOIN_SENSITIVE_CHECK_ERROR = 4405, + RET_TEXT_JOIN_MUST_OVERRIDE = 4406, + RET_TEXT_JOIN_TEXT_EMPTY = 4407, + RET_TEXT_JOIN_TEXT_FORMAT_ERROR = 4408, + RET_TEXT_JOIN_TEXT_UTF8_ERROR = 4409, + RET_TEXT_JOIN_BATCH_REQ_ID_REPEAT = 4410, + RET_TEXT_JOIN_TYPE_NOT_SUPPORT_BATCH_REQ = 4411, + RET_TEXT_JOIN_AVATAR_ID_NOT_EXIST = 4412, + RET_TEXT_JOIN_UNKNOW_TYPE = 4413, + RET_PAM_MISSION_MISSION_ID_ERROR = 4451, + RET_PAM_MISSION_MISSION_EXPIRE = 4452, + RET_CHAT_TYPE_NOT_EXIST = 4501, + RET_MSG_TYPE_NOT_EXIST = 4502, + RET_CHAT_NO_TARGET_UID = 4503, + RET_CHAT_MSG_EMPTY = 4504, + RET_CHAT_MSG_EXCEED_LIMIT = 4505, + RET_CHAT_MSG_SENSITIVE_CHECK_ERROR = 4506, + RET_CHAT_MSG_UTF8_ERROR = 4507, + RET_CHAT_FORBID_SWITCH_OPEN = 4508, + RET_CHAT_FORBID = 4509, + RET_CHAT_MSG_INCLUDE_SPECIAL_STR = 4510, + RET_CHAT_MSG_EMOJI_NOT_EXIST = 4511, + RET_CHAT_MSG_EMOJI_GENDER_NOT_MATCH = 4512, + RET_CHAT_MSG_EMOJI_NOT_MARKED = 4513, + RET_CHAT_MSG_EMOJI_ALREADY_MARKED = 4514, + RET_CHAT_MSG_EMOJI_MARKED_MAX_LIMIT = 4515, + RET_BOXING_CLUB_CHALLENGE_NOT_OPEN = 4601, + RET_MUSEUM_NOT_OPEN = 4651, + RET_MUSEUM_TURN_CNT_NOT_MATCH = 4652, + RET_MUSEUM_PHASE_NOT_REACH = 4653, + RET_MUSEUM_UNKNOW_STUFF = 4654, + RET_MUSEUM_UNKNOW_AREA = 4655, + RET_MUSEUM_UNKNOW_POS = 4656, + RET_MUSEUM_STUFF_ALREADY_IN_AREA = 4657, + RET_MUSEUM_STUFF_NOT_IN_AREA = 4658, + RET_MUSEUM_GET_NPC_REPEAT = 4659, + RET_MUSEUM_GET_NPC_UNLOCK = 4660, + RET_MUSEUM_GET_NPC_NOT_ENOUGH = 4661, + RET_MUSEUM_CHANGE_STUFF_AREA_ERROR = 4662, + RET_MUSEUM_NOT_INIT = 4663, + RET_MUSEUM_EVENT_ERROR = 4664, + RET_MUSEUM_UNKNOW_CHOOSE_EVENT_ID = 4665, + RET_MUSEUM_EVENT_ORDER_NOT_MATCH = 4666, + RET_MUSEUM_EVENT_PHASE_NOT_UNLOCK = 4667, + RET_MUSEUM_EVENT_MISSION_NOT_FOUND = 4668, + RET_MUSEUM_AREA_LEVEL_UP_ALREADY = 4669, + RET_MUSEUM_STUFF_ALREADY_USED = 4670, + RET_MUSEUM_EVENT_ROUND_NOT_UNLOCK = 4671, + RET_MUSEUM_STUFF_IN_AREA = 4672, + RET_MUSEUM_STUFF_DISPATCH = 4673, + RET_MUSEUM_IS_END = 4674, + RET_MUSEUM_STUFF_LEAVING = 4675, + RET_MUSEUM_EVENT_MISSION_NOT_FINISH = 4678, + RET_MUSEUM_COLLECT_REWARD_NOT_EXIST = 4679, + RET_MUSEUM_COLLECT_REWARD_ALREADY_TAKEN = 4680, + RET_MUSEUM_ACCEPT_MISSION_MAX_LIMIT = 4681, + RET_ROGUE_CHALLENGE_NOT_OPEN = 4701, + RET_ROGUE_CHALLENGE_ASSIS_REFRESH_LIMIT = 4702, + RET_ALLEY_NOT_INIT = 4721, + RET_ALLEY_NOT_OPEN = 4722, + RET_ALLEY_MAP_NOT_EXIST = 4724, + RET_ALLEY_EMPTY_POS_LIST = 4725, + RET_ALLEY_LINE_POS_INVALID = 4726, + RET_ALLEY_SHOP_NOT_UNLOCK = 4727, + RET_ALLEY_DEPOT_FULL = 4728, + RET_ALLEY_SHOP_NOT_INCLUDE = 4729, + RET_ALLEY_EVENT_NOT_UNLOCK = 4730, + RET_ALLEY_EVENT_NOT_REFRESH = 4731, + RET_ALLEY_EVENT_STATE_DOING = 4732, + RET_ALLEY_EVENT_STATE_FINISH = 4733, + RET_ALLEY_EVENT_ERROR = 4734, + RET_ALLEY_REWARD_LEVEL_ERROR = 4735, + RET_ALLEY_REWARD_PRESTIGE_NOT_ENOUGH = 4736, + RET_ALLEY_SHIP_EMPTY = 4737, + RET_ALLEY_SHIP_ID_DISMATCH = 4738, + RET_ALLEY_SHIP_NOT_EXIST = 4739, + RET_ALLEY_SHIP_NOT_UNLOCK = 4740, + RET_ALLEY_GOODS_NOT_EXIST = 4741, + RET_ALLEY_GOODS_NOT_UNLOCK = 4742, + RET_ALLEY_PROFIT_NOT_POSITIVE = 4743, + RET_ALLEY_SPECIAL_ORDER_DISMATCH = 4744, + RET_ALLEY_ORDER_GOODS_OVER_LIMIT = 4745, + RET_ALLEY_SPECIAL_ORDER_CONDITION_NOT_MEET = 4746, + RET_ALLEY_DEPOT_SIZE_OVER_LIMIT = 4747, + RET_ALLEY_GOODS_NOT_ENOUGH = 4748, + RET_ALLEY_ORDER_INDEX_INVALID = 4749, + RET_ALLEY_REWARD_ALREADY_TAKE = 4750, + RET_ALLEY_REWARD_NOT_EXIST = 4751, + RET_ALLEY_MAIN_MISSION_NOT_DOING = 4752, + RET_ALLEY_CRITICAL_EVENT_NOT_FINISH = 4753, + RET_ALLEY_SHOP_GOODS_NOT_VALID = 4754, + RET_ALLEY_SLASH_NOT_OPEN = 4755, + RET_ALLEY_PLACING_ANCHOR_INVALID = 4756, + RET_ALLEY_PLACING_GOODS_INDEX_INVALID = 4757, + RET_ALLEY_SAVE_MAP_TOO_QUICK = 4758, + RET_ALLEY_MAP_NOT_LINK = 4759, + RET_ALLEY_FUNDS_NOT_LOWER_BASE = 4760, + RET_ALLEY_EVENT_NOT_FINISH = 4761, + RET_ALLEY_NORMAL_ORDER_NOT_MEET = 4762, + RET_PLAYER_RETURN_NOT_OPEN = 4801, + RET_PLAYER_RETURN_IS_SIGNED = 4802, + RET_PLAYER_RETURN_POINT_NOT_ENOUGH = 4803, + RET_PLAYER_RETURN_CONDITION_INVALID = 4804, + RET_PLAYER_RETURN_HAS_SIGNED = 4805, + RET_PLAYER_RETURN_REWARD_TAKEN = 4806, + RET_AETHER_DIVIDE_NO_LINEUP = 4851, + RET_AETHER_DIVIDE_LINEUP_INVALID = 4852, + RET_CHAT_BUBBLE_ID_ERROR = 4901, + RET_CHAT_BUBBLE_ID_NOT_UNLOCK = 4902, + RET_PHONE_THEME_ID_ERROR = 4903, + RET_PHONE_THEME_ID_NOT_UNLOCK = 4904, + RET_CHAT_BUBBLE_SELECT_IS_CURRENT = 4905, + RET_PHONE_THEME_SELECT_IS_CURRENT = 4906, + RET_CHESS_ROGUE_CONFIG_NOT_FOUND = 4951, + RET_CHESS_ROGUE_CONFIG_INVALID = 4952, + RET_CHESS_ROGUE_NO_VALID_ROOM = 4963, + RET_CHESS_ROGUE_NO_CELL_INFO = 4964, + RET_CHESS_ROGUE_CELL_NOT_FINISH = 4965, + RET_CHESS_ROGUE_CELL_IS_LOCKED = 4966, + RET_CHESS_ROGUE_SCHEDULE_NOT_MATCH = 4967, + RET_CHESS_ROGUE_STATUS_FAIL = 4968, + RET_CHESS_ROGUE_AREA_NOT_EXIST = 4969, + RET_CHESS_ROGUE_LINEUP_FAIL = 4970, + RET_CHESS_ROGUE_AEON_FAIL = 4980, + RET_CHESS_ROGUE_ENTER_CELL_FAIL = 4981, + RET_CHESS_ROGUE_ROLL_DICE_FAIL = 4982, + RET_CHESS_ROGUE_DICE_STATUS_FAIL = 4983, + RET_CHESS_ROGUE_DICE_CNT_NOT_FULL = 4984, + RET_CHESS_ROGUE_UNLOCK = 4985, + RET_CHESS_ROGUE_PICK_AVATAR_FAIL = 4986, + RET_CHESS_ROGUE_AVATAR_INVALID = 4987, + RET_CHESS_ROGUE_CELL_CAN_NOT_SELECT = 4988, + RET_CHESS_ROGUE_DICE_CONFIRMED = 4989, + RET_CHESS_ROGUE_NOUS_DICE_NOT_MATCH = 4990, + RET_CHESS_ROGUE_NOUS_DICE_RARITY_FAIL = 4991, + RET_CHESS_ROGUE_NOUS_DICE_SURFACE_DUPLICATE = 4992, + RET_CHESS_ROGUE_NOT_IN_ROGUE = 4993, + RET_CHESS_ROGUE_NOUS_DICE_BRANCH_LIMIT = 4994, + RET_HELIOBUS_NOT_OPEN = 5101, + RET_HELIOBUS_SNS_POST_NOT_UNLOCK = 5102, + RET_HELIOBUS_SNS_ALREADY_READ = 5103, + RET_HELIOBUS_SNS_ALREADY_LIKED = 5104, + RET_HELIOBUS_SNS_ALREADY_COMMENTED = 5105, + RET_HELIOBUS_SNS_IN_MISSION = 5106, + RET_HELIOBUS_SNS_ALREADY_POSTED = 5107, + RET_HELIOBUS_SNS_NOT_DOING_MISSION = 5108, + RET_HELIOBUS_REWARD_LEVEL_MAX = 5109, + RET_HELIOBUS_INCOME_NOT_ENOUGH = 5110, + RET_HELIOBUS_SNS_COMMENT_NOT_UNLOCK = 5111, + RET_HELIOBUS_CHALLENGE_NOT_UNLOCK = 5112, + RET_HELIOBUS_CHALLENGE_ID_ERROR = 5113, + RET_HELIOBUS_SKILL_NOT_UNLOCK = 5114, + RET_HELIOBUS_ACCEPT_POST_MISSION_FAIL = 5115, + RET_HELIOBUS_SKILL_NOT_SELECTED = 5116, + RET_HELIOBUS_PLANE_TYPE_INVALID = 5117, + RET_REDDOT_PARAM_INVALID = 5151, + RET_REDDOT_ACTIVITY_NOT_OPEN = 5152, + RET_ROGUE_ENDLESS_ACTIVITY_CONFIG_ERROR = 5201, + RET_ROGUE_ENDLESS_ACTIVITY_NOT_OPEN = 5202, + RET_ROGUE_ENDLESS_ACTIVITY_OVER_BONUS_REWARD_LIMIT = 5203, + RET_ROGUE_ENDLESS_ACTIVITY_SCORE_NOT_MEET = 5204, + RET_ROGUE_ENDLESS_ACTIVITY_REWARD_LEVLE_ALREADY_TAKE = 5205, + RET_HEART_DIAL_SCRIPT_NOT_FOUND = 5251, + RET_HEART_DIAL_SCRIPT_EMOTION_THE_SAME = 5252, + RET_HEART_DIAL_SCRIPT_STEP_NOT_NORMAL = 5253, + RET_HEART_DIAL_SCRIPT_CONDITION_NOT_MATCH = 5254, + RET_HEART_DIAL_SCRIPT_SUBMIT_ITEM_NUM_NOT_MATCH = 5255, + RET_HEART_DIAL_SCRIPT_SUBMIT_ITEM_ID_NOT_MATCH = 5256, + RET_HEART_DIAL_DIALOGUE_NOT_FOUND = 5257, + RET_HEART_DIAL_DIALOGUE_ALREADY_PERFORMED = 5258, + RET_HEART_DIAL_NPC_NOT_FOUND = 5259, + RET_HEART_DIAL_TRACE_CONFIG_NOT_FOUND = 5260, + RET_HEART_DIAL_FLOOR_TRACE_EXIST = 5261, + RET_HEART_DIAL_TRACE_FLOOR_NOT_MATCH = 5262, + RET_TRAVEL_BROCHURE_CONFIG_ERROR = 5301, + RET_TRAVEL_BROCHURE_PARAM_INVALID = 5302, + RET_TRAVEL_BROCHURE_LOCKED = 5303, + RET_TRAVEL_BROCHURE_CANNOT_OPERATE = 5304, + RET_TRAVEL_BROCHURE_WORLD_ID_NOT_MATCH = 5305, + RET_TRAVEL_BROCHURE_HAS_NO_WORLD_BOOK = 5306, + RET_TRAVEL_BROCHURE_PAGE_FULL = 5307, + RET_MAP_ROTATION_NOT_IN_REGION = 5351, + RET_MAP_ROTATION_ROTATER_ALREADY_DEPLOYED = 5352, + RET_MAP_ROTATION_ENERGY_NOT_ENOUGH = 5353, + RET_MAP_ROTATION_ENTITY_NOT_ON_CUR_POSE = 5354, + RET_MAP_ROTATION_ROTATER_NOT_DEPLOYED = 5355, + RET_MAP_ROTATION_POSE_ROTATER_MISMATCH = 5356, + RET_MAP_ROTATION_ROTATER_NOT_REMOVABLE = 5357, + RET_MAP_ROTATION_ROTATER_DISPOSABLE = 5358, + RET_SPACE_ZOO_ACTIVITY_CAT_NOT_FOUND = 5401, + RET_SPACE_ZOO_ACTIVITY_CAT_PARAM_INVALID = 5402, + RET_SPACE_ZOO_ACTIVITY_CAT_ITEM_NOT_ENOUGH = 5403, + RET_SPACE_ZOO_ACTIVITY_CAT_BAG_FULL = 5404, + RET_SPACE_ZOO_ACTIVITY_CAT_NOT_TO_MUTATE = 5405, + RET_SPACE_ZOO_ACTIVITY_CAT_STATE_ERROR = 5406, + RET_SPACE_ZOO_ACTIVITY_CAT_CATTERY_LOCKED = 5407, + RET_SPACE_ZOO_ACTIVITY_CAT_OUT_NOW = 5408, + RET_SPACE_ZOO_ACTIVITY_CAT_CONFIG_NOT_FOUND = 5409, + RET_SPACE_ZOO_ACTIVITY_CAT_FEATURE_NOT_FOUND = 5410, + RET_SPACE_ZOO_ACTIVITY_CAT_ADD_CAT_ERROR = 5411, + RET_SPACE_ZOO_ACTIVITY_CAT_MONEY_NOT_ENOUGH = 5412, + RET_SPACE_ZOO_ACTIVITY_CAT_COND_NOT_MATCH = 5413, + RET_STRONG_CHALLENGE_ACTIVITY_STAGE_CFG_MISS = 5501, + RET_STRONG_CHALLENGE_ACTIVITY_STAGE_NOT_OPEN = 5502, + RET_STRONG_CHALLENGE_ACTIVITY_BUFF_ERROR = 5503, + RET_ROLL_SHOP_NOT_FOUND = 5551, + RET_ROLL_SHOP_GROUP_EMPTY = 5552, + RET_ROLL_SHOP_EMPTY = 5553, + RET_ROLL_SHOP_GACHA_REQ_DUPLICATED = 5554, + RET_ROLL_SHOP_RANDOM_ERROR = 5555, + RET_ROLL_SHOP_GROUP_TYPE_NOT_FOUND = 5556, + RET_ROLL_SHOP_HAS_STORED_REWARD_ALREADY = 5557, + RET_ROLL_SHOP_NO_STORED_REWARD = 5558, + RET_ROLL_SHOP_NOT_IN_VALID_SCENE = 5559, + RET_ROLL_SHOP_INVALID_ROLL_SHOP_TYPE = 5560, + RET_ACTIVITY_RAID_COLLECTION_PREV_NOT_FINISH = 5601, + RET_OFFERING_NOT_UNLOCK = 5651, + RET_OFFERING_LEVEL_NOT_UNLOCK = 5652, + RET_OFFERING_REACH_MAX_LEVEL = 5653, + RET_OFFERING_ITEM_NOT_ENOUGH = 5654, + RET_OFFERING_LONGTAIL_NOT_OPEN = 5655, + RET_OFFERING_REWARD_CONDITION = 5656, + RET_DRINK_MAKER_CHAT_INVALID = 5701, + RET_DRINK_MAKER_PARAM_INVALID = 5702, + RET_DRINK_MAKER_PARAM_NOT_UNLOCK = 5703, + RET_DRINK_MAKER_CONFIG_NOT_FOUND = 5704, + RET_DRINK_MAKER_NOT_LAST_CHAT = 5705, + RET_DRINK_MAKER_DAY_AND_FREE_PHASE_NOT_OPEN = 5706, + RET_MONOPOLY_NOT_OPEN = 5751, + RET_MONOPOLY_CONFIG_ERROR = 5752, + RET_MONOPOLY_DICE_NOT_ENOUGH = 5753, + RET_MONOPOLY_CUR_CELL_NOT_FINISH = 5754, + RET_MONOPOLY_COIN_NOT_ENOUGH = 5755, + RET_MONOPOLY_CELL_WAIT_PENDING = 5756, + RET_MONOPOLY_CELL_STATE_ERROR = 5757, + RET_MONOPOLY_CELL_CONTENT_ERROR = 5758, + RET_MONOPOLY_ITEM_NOT_ENOUGH = 5759, + RET_MONOPOLY_CELL_CONTENT_CANNOT_GIVEUP = 5760, + RET_MONOPOLY_ASSET_LEVEL_INVALID = 5761, + RET_MONOPOLY_TURN_NOT_FINISH = 5762, + RET_MONOPOLY_GUIDE_NOT_FINISH = 5763, + RET_MONOPOLY_RAFFLE_REWARD_REISSUED = 5764, + RET_MONOPOLY_NO_GAME_ACTIVE = 5771, + RET_MONOPOLY_GAME_RATIO_NOT_INCREASABLE = 5772, + RET_MONOPOLY_GAME_RATIO_MAX = 5773, + RET_MONOPOLY_GAME_TARGET_RATIO_INVALID = 5774, + RET_MONOPOLY_GAME_BINGO_FLIP_POS_INVALID = 5775, + RET_MONOPOLY_GAME_GUESS_ALREADY_CHOOSE = 5776, + RET_MONOPOLY_GAME_GUESS_CHOOSE_INVALID = 5777, + RET_MONOPOLY_GAME_GUESS_INFORMATION_ALREADY_BOUGHT = 5778, + RET_MONOPOLY_GAME_RAISE_RATIO_NOT_UNLOCK = 5779, + RET_MONOPOLY_FRIEND_NOT_SYNCED = 5785, + RET_MONOPOLY_GET_FRIEND_RANKING_LIST_IN_CD = 5786, + RET_MONOPOLY_LIKE_TARGET_NOT_FRIEND = 5787, + RET_MONOPOLY_DAILY_ALREADY_LIKED = 5788, + RET_MONOPOLY_SOCIAL_EVENT_STATUS_NOT_MATCH = 5789, + RET_MONOPOLY_SOCIAL_EVENT_SERVER_CACHE_NOT_EXIST = 5790, + RET_MONOPOLY_ACTIVITY_ID_NOT_MATCH = 5791, + RET_MONOPOLY_RAFFLE_POOL_NOT_EXIST = 5792, + RET_MONOPOLY_RAFFLE_POOL_TIME_NOT_MATCH = 5793, + RET_MONOPOLY_RAFFLE_POOL_PHASE_NOT_MEET = 5794, + RET_MONOPOLY_RAFFLE_POOL_SHOW_TIME_NOT_MEET = 5795, + RET_MONOPOLY_RAFFLE_TICKET_NOT_FOUND = 5796, + RET_MONOPOLY_RAFFLE_TICKET_TIME_NOT_MEET = 5797, + RET_MONOPOLY_RAFFLE_TICKET_REWARD_ALREADY_TAKEN = 5798, + RET_MONOPOLY_RAFFLE_POOL_NOT_IN_RAFFLE_TIME = 5799, + RET_MONOPOLY_MBTI_REPORT_REWARD_ALREADY_TAKEN = 5800, + RET_EVOLVE_BUILD_LEVEL_GAMING = 5801, + RET_EVEOLVE_BUILD_LEVEL_BAN_RANDOM = 5802, + RET_EVOLVE_BUILD_FIRST_REWARD_ALREADY_TAKEN = 5803, + RET_EVOLVE_BUILD_LEVEL_UNFINISH = 5804, + RET_EVOLVE_BUILD_SHOP_ABILITY_MAX_LEVEL = 5805, + RET_EVOLVE_BUILD_SHOP_ABILITY_MIN_LEVEL = 5806, + RET_EVOLVE_BUILD_SHOP_ABILITY_NOT_GET = 5807, + RET_EVOLVE_BUILD_LEVEL_LOCK = 5808, + RET_EVOLVE_BUILD_EXP_NOT_ENOUGH = 5809, + RET_EVOLVE_BUILD_SHOP_ABILITY_LEVEL_ERROR = 5810, + RET_EVOLVE_BUILD_ACTIVITY_NOT_OPEN = 5811, + RET_EVOLVE_BUILD_SHOP_ABILITY_EMPTY = 5812, + RET_EVOLVE_BUILD_LEVEL_NOT_START = 5813, + RET_EVOLVE_BUILD_SHOP_LOCK = 5814, + RET_EVOLVE_BUILD_REWARD_LOCK = 5815, + RET_EVOLVE_BUILD_REWARD_LEVEL_MAX = 5816, + RET_EVOLVE_BUILD_REWARD_ALREADY_ALL_TAKEN = 5717, + RET_CLOCK_PARK_CONFIG_ERROR = 5851, + RET_CLOCK_PARK_EFFECT_ERROR = 5852, + RET_CLOCK_PARK_SCRIPT_ALREADY_UNLOCK = 5853, + RET_CLOCK_PARK_SCRIPT_UNLOCK_CONDITION_NOT_MEET = 5854, + RET_CLOCK_PARK_TALENT_ALREADY_UNLOCK = 5855, + RET_CLOCK_PARK_SCRIPT_LOCKED = 5856, + RET_CLOCK_PARK_HAS_ONGOING_SCRIPT = 5857, + RET_CLOCK_PARK_NO_ONGOING_SCRIPT = 5858, + RET_CLOCK_PARK_DICE_PLACEMENT_ERROR = 5859, + RET_CLOCK_PARK_MISMATCH_STATUS = 5860, + RET_CLOCK_PARK_NO_BUFF = 5861, + RET_CLOCK_PARK_SLOT_MACHINE_GACHA_REQ_DUPLICATED = 5862, + RET_CLOCK_PARK_SLOT_MACHINE_COST_NOT_ENOUGH = 5863, + RET_CLOCK_PARK_SLOT_MACHINE_GACHA_CNT_EXCEED_LIMIT = 5864, + RET_CLOCK_PARK_NOT_OPEN = 5865, + RET_TOURN_ROGUE_STATUS_MISMATCH = 5901, + RET_MATCH_ALREADY_IN_MATCH = 6201, + RET_MATCH_NOT_IN_MATCH = 6202, + RET_MATCH_PLAY_NOT_OPEN = 6203, + RET_CROSS_STATE_ERROR = 6204, + RET_MATCH_VERSION_NOT_EQUAL = 6205, + RET_MATCH_PLAYER_NOT_IN_LOBBY_ROOM = 6206, + RET_LOBBY_STATE_NOT_MATCH = 6207, + RET_LOBBY_ROOM_NOT_EXIST = 6208, + RET_LOBBY_ROOM_PALYER_FULL = 6209, + RET_LOBBY_ROOM_PALYER_NOT_READY = 6210, + RET_LOBBY_ROOM_PALYER_FIGHTING = 6211, + RET_FIGHT_ROOM_NOT_EXIST = 6250, + RET_FIGHT_MATCH3_PLAYER_STATE_ERR = 6251, + RET_FIGHT_MATCH3_ROOM_STATE_ERR = 6252, + RET_SWORD_TRAINING_NO_ACTIVE_GAME = 6301, + RET_SWORD_TRAINING_NO_PENDING_ACTION_MATCH = 6302, + RET_SWORD_TRAINING_PARTNER_ABILITY_INVALID = 6303, + RET_SWORD_TRAINING_SKILL_ALREADY_LEARNED = 6304, + RET_SWORD_TRAINING_CONDITION_NOT_MEET = 6305, + RET_SWORD_TRAINING_PARENT_SKILL_NOT_LEARNED = 6306, + RET_SWORD_TRAINING_SKILL_TYPE_NOT_UNLOCK = 6307, + RET_SWORD_TRAINING_GAME_ALREADY_EXIST = 6308, + RET_SWORD_TRAINING_ENDING_HINT_NOT_MATCH = 6309, + RET_SWORD_TRAINING_STORYLINE_CONFIG_NOT_FOUND = 6310, + RET_SWORD_TRAINING_STORY_CONFIG_NOT_FOUND = 6311, + RET_SWORD_TRAINING_UNLOCK_NOT_FINISH = 6312, + RET_SWORD_TRAINING_OPTION_MISMATCH = 6313, + RET_SWORD_TRAINING_RESTORE_WITHOUT_EXAM_FAILED = 6314, + RET_SWORD_TRAINING_NO_RESTORE_GAME_AVAILABLE = 6315, + RET_SWORD_TRAINING_ENDING_STORY_NOT_MATCH = 6316, + RET_SWORD_TRAINING_ENDING_NOT_FINISH = 6317, + RET_SWORD_TRAINING_ENDING_REWARD_TAKEN = 6318, + RET_SWORD_TRAINING_COMBAT_RANK_NOT_CHANGE = 6319, + RET_SWORD_TRAINING_DIRECT_BATTLE_DISABLE = 6320, + _, +}; + +pub const CmdActivityType = enum(i32) { + CmdActivityTypeNone = 0, + CmdTakeTrialActivityRewardScRsp = 2633, + CmdTakeTrialActivityRewardCsReq = 2668, + CmdTakeMonsterResearchActivityRewardCsReq = 2673, + CmdLeaveTrialActivityScRsp = 2632, + CmdGetLoginActivityCsReq = 2618, + CmdSubmitMonsterResearchActivityMaterialCsReq = 2640, + CmdStartTrialActivityScRsp = 2667, + CmdEnterTrialActivityStageScRsp = 2620, + CmdTakeLoginActivityRewardCsReq = 2629, + CmdTakeMonsterResearchActivityRewardScRsp = 2608, + CmdStartTrialActivityCsReq = 2690, + CmdGetActivityScheduleConfigScRsp = 2649, + CmdTrialActivityDataChangeScNotify = 2700, + CmdGetMonsterResearchActivityDataScRsp = 2662, + CmdTakeLoginActivityRewardScRsp = 2637, + CmdGetMonsterResearchActivityDataCsReq = 2691, + CmdSubmitMonsterResearchActivityMaterialScRsp = 2648, + CmdCurTrialActivityScNotify = 2694, + CmdLeaveTrialActivityCsReq = 2603, + CmdGetTrialActivityDataScRsp = 2688, + CmdEnterTrialActivityStageCsReq = 2610, + CmdGetActivityScheduleConfigCsReq = 2658, + CmdGetLoginActivityScRsp = 2674, + CmdGetTrialActivityDataCsReq = 2636, + _, +}; + +pub const PCEGPGNGKHN = enum(i32) { + TRIAL_ACTIVITY_STATUS_NONE = 0, + TRIAL_ACTIVITY_STATUS_FINISH = 1, + _, +}; + +pub const CmdAdventureType = enum(i32) { + CmdAdventureTypeNone = 0, + CmdGetFarmStageGachaInfoCsReq = 1329, + CmdEnterAdventureScRsp = 1374, + CmdGetFarmStageGachaInfoScRsp = 1337, + CmdEnterAdventureCsReq = 1318, + _, +}; + +pub const OIENGPFPGEO = enum(i32) { + CmdAetherDivideTypeNone = 0, + CmdStartAetherDivideStageBattleCsReq = 4873, + CmdStartAetherDivideStageBattleScRsp = 4808, + CmdClearAetherDividePassiveSkillScRsp = 4862, + CmdAetherDivideLineupScNotify = 4859, + CmdAetherDivideFinishChallengeScNotify = 4847, + CmdAetherDivideSpiritInfoScNotify = 4877, + CmdGetAetherDivideInfoScRsp = 4857, + CmdSwitchAetherDivideLineUpSlotCsReq = 4840, + CmdSetAetherDivideLineUpCsReq = 4846, + CmdAetherDivideTakeChallengeRewardScRsp = 4806, + CmdAetherDivideRefreshEndlessCsReq = 4802, + CmdAetherDivideRefreshEndlessScNotify = 4809, + CmdLeaveAetherDivideSceneScRsp = 4837, + CmdClearAetherDividePassiveSkillCsReq = 4891, + CmdEnterAetherDivideSceneScRsp = 4874, + CmdGetAetherDivideChallengeInfoScRsp = 4892, + CmdAetherDivideTakeChallengeRewardCsReq = 4856, + CmdEnterAetherDivideSceneCsReq = 4818, + CmdSetAetherDivideLineUpScRsp = 4898, + CmdLeaveAetherDivideSceneCsReq = 4829, + CmdAetherDivideSkillItemScNotify = 4838, + CmdAetherDivideTainerInfoScNotify = 4861, + CmdStartAetherDivideSceneBattleScRsp = 4849, + CmdStartAetherDivideSceneBattleCsReq = 4858, + CmdEquipAetherDividePassiveSkillCsReq = 4883, + CmdSwitchAetherDivideLineUpSlotScRsp = 4848, + CmdGetAetherDivideChallengeInfoCsReq = 4824, + CmdAetherDivideRefreshEndlessScRsp = 4813, + CmdStartAetherDivideChallengeBattleScRsp = 4841, + CmdAetherDivideSpiritExpUpCsReq = 4811, + CmdAetherDivideSpiritExpUpScRsp = 4821, + CmdStartAetherDivideChallengeBattleCsReq = 4828, + CmdEquipAetherDividePassiveSkillScRsp = 4822, + CmdGetAetherDivideInfoCsReq = 4889, + _, +}; + +pub const PLHBKMAICHJ = enum(i32) { + CmdAlleyTypeNone = 0, + CmdSaveLogisticsScRsp = 4792, + CmdTakePrestigeRewardCsReq = 4789, + CmdAlleyFundsScNotify = 4711, + CmdAlleyShopLevelScNotify = 4721, + CmdGetSaveLogisticsMapCsReq = 4738, + CmdAlleyShipmentEventEffectsScNotify = 4761, + CmdAlleyEventEffectNotify = 4764, + CmdStartAlleyEventScRsp = 4741, + CmdAlleyTakeEventRewardCsReq = 4709, + CmdAlleyGuaranteedFundsScRsp = 4713, + CmdTakePrestigeRewardScRsp = 4757, + CmdAlleyPlacingGameCsReq = 4746, + CmdLogisticsScoreRewardSyncInfoScNotify = 4780, + CmdAlleyShipUsedCountScNotify = 4759, + CmdGetSaveLogisticsMapScRsp = 4782, + CmdAlleyPlacingGameScRsp = 4798, + CmdRefreshAlleyOrderScRsp = 4762, + CmdRefreshAlleyOrderCsReq = 4791, + CmdSaveLogisticsCsReq = 4724, + CmdAlleyGuaranteedFundsCsReq = 4702, + CmdLogisticsGameCsReq = 4729, + CmdLogisticsGameScRsp = 4737, + CmdLogisticsDetonateStarSkiffScRsp = 4770, + CmdGetAlleyInfoCsReq = 4718, + CmdPrestigeLevelUpScRsp = 4708, + CmdAlleyEventChangeNotify = 4719, + CmdAlleyTakeEventRewardScRsp = 4756, + CmdPrestigeLevelUpCsReq = 4773, + CmdGetAlleyInfoScRsp = 4774, + CmdAlleyShipUnlockScNotify = 4777, + CmdAlleyOrderChangedScNotify = 4740, + CmdLogisticsDetonateStarSkiffCsReq = 4706, + CmdLogisticsInfoScNotify = 4747, + CmdStartAlleyEventCsReq = 4728, + _, +}; + +pub const CJCCGKBDMEA = enum(i32) { + LEFT = 0, + RIGHT = 1, + UP = 2, + DOWN = 3, + LEFT_UP = 4, + LEFT_DOWN = 5, + RIGHT_UP = 6, + RIGHT_DOWN = 7, + _, +}; + +pub const MOBKBMLDDJA = enum(i32) { + ALLEY_EVENT_TYPE_NONE = 0, + ALLEY_MAIN_EVENT = 1, + ALLEY_CRITICAL_EVENT = 2, + ALLEY_DAILY_EVENT = 3, + _, +}; + +pub const OGAOBHGMLBH = enum(i32) { + ALLEY_STATE_NONE = 0, + ALLEY_EVENT_DOING = 1, + ALLEY_EVENT_FINISH = 2, + ALLEY_EVENT_REWARDED = 3, + _, +}; + +pub const CmdArchiveType = enum(i32) { + CmdArchiveTypeNone = 0, + CmdGetUpdatedArchiveDataCsReq = 2329, + CmdGetArchiveDataScRsp = 2374, + CmdGetArchiveDataCsReq = 2318, + CmdGetUpdatedArchiveDataScRsp = 2337, + _, +}; + +pub const CmdAvatarType = enum(i32) { + CmdAvatarTypeNone = 0, + CmdDressAvatarSkinScRsp = 311, + CmdRankUpAvatarCsReq = 398, + CmdRankUpAvatarScRsp = 383, + CmdMarkAvatarCsReq = 392, + CmdTakeOffRelicCsReq = 362, + CmdTakePromotionRewardCsReq = 348, + CmdLevelUpSpecialSkillTreeCsReq = 361, + CmdUnlockSpecialSkillTreeScNotify = 382, + CmdLevelUpSpecialSkillTreeScRsp = 338, + CmdUnlockSkilltreeCsReq = 358, + CmdDressAvatarSkinCsReq = 308, + CmdTakeOffRelicScRsp = 340, + CmdDressRelicAvatarCsReq = 322, + CmdDressAvatarScRsp = 364, + CmdUnlockSkilltreeScRsp = 349, + CmdPromoteAvatarScRsp = 341, + CmdAvatarExpUpCsReq = 329, + CmdAddAvatarScNotify = 346, + CmdTakeOffAvatarSkinScRsp = 377, + CmdTakePromotionRewardScRsp = 373, + CmdGetAvatarDataScRsp = 374, + CmdPromoteAvatarCsReq = 328, + CmdDressAvatarCsReq = 319, + CmdDressRelicAvatarScRsp = 391, + CmdMarkAvatarScRsp = 347, + CmdTakeOffAvatarSkinCsReq = 321, + CmdGetAvatarDataCsReq = 318, + CmdUnlockAvatarSkinScNotify = 324, + CmdTakeOffEquipmentScRsp = 357, + CmdAvatarExpUpScRsp = 337, + CmdTakeOffEquipmentCsReq = 389, + _, +}; + +pub const AddAvatarSrc = enum(i32) { + ADD_AVATAR_SRC_NONE = 0, + ADD_AVATAR_SRC_GACHA = 1, + ADD_AVATAR_SRC_ROGUE = 2, + _, +}; + +pub const CmdBattleType = enum(i32) { + CmdBattleTypeNone = 0, + CmdSyncClientResVersionScRsp = 141, + CmdQuitBattleScRsp = 137, + CmdServerSimulateBattleFinishScNotify = 157, + CmdBattleLogReportCsReq = 164, + CmdPVEBattleResultScRsp = 174, + CmdReBattleAfterBattleLoseCsNotify = 146, + CmdSyncClientResVersionCsReq = 128, + CmdQuitBattleScNotify = 119, + CmdBattleLogReportScRsp = 189, + CmdGetCurBattleInfoScRsp = 149, + CmdPVEBattleResultCsReq = 118, + CmdQuitBattleCsReq = 129, + CmdRebattleByClientCsNotify = 198, + CmdGetCurBattleInfoCsReq = 158, + _, +}; + +pub const AOEBHPNIKOO = enum(i32) { + CmdBattleCollegeTypeNone = 0, + CmdGetBattleCollegeDataCsReq = 5718, + CmdStartBattleCollegeCsReq = 5737, + CmdBattleCollegeDataChangeScNotify = 5729, + CmdGetBattleCollegeDataScRsp = 5774, + CmdStartBattleCollegeScRsp = 5758, + _, +}; + +pub const FLHHMFFFJIC = enum(i32) { + CmdBattlePassTypeNone = 0, + CmdTakeBpRewardCsReq = 3037, + CmdTakeBpRewardScRsp = 3058, + CmdBattlePassInfoNotify = 3018, + CmdBuyBpLevelScRsp = 3028, + CmdTakeAllRewardScRsp = 3019, + CmdTakeAllRewardCsReq = 3041, + CmdBuyBpLevelCsReq = 3049, + _, +}; + +pub const OFMFCLIFILH = enum(i32) { + BP_TIER_TYPE_NONE = 0, + BP_TIER_TYPE_FREE = 1, + BP_TIER_TYPE_PREMIUM_1 = 2, + BP_TIER_TYPE_PREMIUM_2 = 3, + _, +}; + +pub const HEFEKEALDNH = enum(i32) { + BP_REWARAD_TYPE_NONE = 0, + BP_REWARAD_TYPE_FREE = 1, + BP_REWARAD_TYPE_PREMIUM_1 = 2, + BP_REWARAD_TYPE_PREMIUM_2 = 3, + BP_REWARAD_TYPE_PREMIUM_OPTIONAL = 4, + _, +}; + +pub const EPOFPCEGABD = enum(i32) { + CmdBoxingClubTypeNone = 0, + CmdMatchBoxingClubOpponentCsReq = 4229, + CmdGetBoxingClubInfoCsReq = 4218, + CmdGiveUpBoxingClubChallengeScRsp = 4241, + CmdSetBoxingClubResonanceLineupCsReq = 4246, + CmdChooseBoxingClubResonanceScRsp = 4257, + CmdBoxingClubRewardScNotify = 4219, + CmdGetBoxingClubInfoScRsp = 4274, + CmdStartBoxingClubBattleScRsp = 4249, + CmdChooseBoxingClubResonanceCsReq = 4289, + CmdSetBoxingClubResonanceLineupScRsp = 4298, + CmdChooseBoxingClubStageOptionalBuffScRsp = 4222, + CmdBoxingClubChallengeUpdateScNotify = 4264, + CmdStartBoxingClubBattleCsReq = 4258, + CmdMatchBoxingClubOpponentScRsp = 4237, + CmdGiveUpBoxingClubChallengeCsReq = 4228, + CmdChooseBoxingClubStageOptionalBuffCsReq = 4283, + _, +}; + +pub const CmdChallengeType = enum(i32) { + CmdChallengeTypeNone = 0, + CmdGetChallengeGroupStatisticsScRsp = 1762, + CmdGetCurChallengeScRsp = 1789, + CmdLeaveChallengeScRsp = 1749, + CmdTakeChallengeRewardCsReq = 1783, + CmdEnterChallengeNextPhaseCsReq = 1721, + CmdChallengeSettleNotify = 1728, + CmdLeaveChallengeCsReq = 1758, + CmdStartChallengeCsReq = 1729, + CmdGetCurChallengeCsReq = 1764, + CmdRestartChallengePhaseCsReq = 1708, + CmdEnterChallengeNextPhaseScRsp = 1777, + CmdGetChallengeGroupStatisticsCsReq = 1791, + CmdStartPartialChallengeCsReq = 1740, + CmdStartChallengeScRsp = 1737, + CmdGetChallengeScRsp = 1774, + CmdGetChallengeCsReq = 1718, + CmdStartPartialChallengeScRsp = 1748, + CmdTakeChallengeRewardScRsp = 1722, + CmdChallengeLineupNotify = 1757, + CmdRestartChallengePhaseScRsp = 1711, + CmdChallengeBossPhaseSettleNotify = 1724, + _, +}; + +pub const ChallengeStatus = enum(i32) { + CHALLENGE_UNKNOWN = 0, + CHALLENGE_DOING = 1, + CHALLENGE_FINISH = 2, + CHALLENGE_FAILED = 3, + _, +}; + +pub const KLDLPJFAPCH = enum(i32) { + CmdChatTypeNone = 0, + CmdGetLoginChatInfoCsReq = 3983, + CmdSendMsgScRsp = 3974, + CmdRevcMsgScNotify = 3929, + CmdPrivateMsgOfflineUsersScNotify = 3937, + CmdMarkChatEmojiScRsp = 3957, + CmdGetChatFriendHistoryCsReq = 3928, + CmdGetLoginChatInfoScRsp = 3922, + CmdGetChatFriendHistoryScRsp = 3941, + CmdSendMsgCsReq = 3918, + CmdGetChatEmojiListCsReq = 3919, + CmdMarkChatEmojiCsReq = 3989, + CmdGetChatEmojiListScRsp = 3964, + CmdGetPrivateChatHistoryScRsp = 3949, + CmdGetPrivateChatHistoryCsReq = 3958, + CmdBatchMarkChatEmojiScRsp = 3998, + CmdBatchMarkChatEmojiCsReq = 3946, + _, +}; + +pub const HDEAHHEPHOH = enum(i32) { + CmdChessRogueTypeNone = 0, + CmdChessRogueRollDiceScRsp = 5471, + CmdFinishChessRogueSubStoryScRsp = 5407, + CmdChessRogueUpdateDicePassiveAccumulateValueScNotify = 5548, + CmdChessRogueUpdateAeonModifierValueScNotify = 5475, + CmdGetChessRogueNousStoryInfoScRsp = 5466, + CmdChessRogueQueryBpCsReq = 5564, + CmdChessRogueGiveUpRollScRsp = 5455, + CmdChessRogueLeaveScRsp = 5587, + CmdChessRogueSkipTeachingLevelCsReq = 5519, + CmdChessRogueUpdateDiceInfoScNotify = 5447, + CmdFinishChessRogueSubStoryCsReq = 5411, + CmdChessRogueNousGetRogueTalentInfoCsReq = 5539, + CmdChessRogueEnterCellCsReq = 5493, + CmdSyncChessRogueMainStoryFinishScNotify = 5438, + CmdChessRogueRollDiceCsReq = 5450, + CmdChessRogueCheatRollScRsp = 5567, + CmdChessRogueSelectBpCsReq = 5406, + CmdChessRogueEnterNextLayerCsReq = 5473, + CmdChessRogueCellUpdateNotify = 5412, + CmdChessRogueMoveCellNotify = 5536, + CmdChessRogueQueryAeonDimensionsScRsp = 5576, + CmdChessRogueUpdateReviveInfoScNotify = 5420, + CmdEnterChessRogueAeonRoomCsReq = 5452, + CmdChessRogueNousEditDiceCsReq = 5445, + CmdEnhanceChessRogueBuffScRsp = 5505, + CmdGetChessRogueStoryAeonTalkInfoScRsp = 5500, + CmdChessRogueSelectCellScRsp = 5442, + CmdEnhanceChessRogueBuffCsReq = 5404, + CmdChessRogueChangeyAeonDimensionNotify = 5512, + CmdChessRogueSelectBpScRsp = 5526, + CmdChessRogueLeaveCsReq = 5507, + CmdChessRogueReviveAvatarScRsp = 5470, + CmdChessRogueConfirmRollCsReq = 5415, + CmdChessRogueEnterScRsp = 5590, + CmdChessRogueLayerAccountInfoNotify = 5565, + CmdChessRogueNousEnableRogueTalentCsReq = 5531, + CmdChessRogueEnterCsReq = 5521, + CmdGetChessRogueBuffEnhanceInfoScRsp = 5421, + CmdChessRogueGoAheadCsReq = 5504, + CmdChessRogueQuitCsReq = 5549, + CmdChessRogueSkipTeachingLevelScRsp = 5489, + CmdGetChessRogueStoryAeonTalkInfoCsReq = 5456, + CmdSelectChessRogueSubStoryScRsp = 5517, + CmdChessRogueNousGetRogueTalentInfoScRsp = 5571, + CmdChessRogueStartScRsp = 5570, + CmdChessRogueGiveUpCsReq = 5524, + CmdGetChessRogueBuffEnhanceInfoCsReq = 5534, + CmdEnterChessRogueAeonRoomScRsp = 5435, + CmdSelectChessRogueNousSubStoryScRsp = 5535, + CmdChessRogueNousEditDiceScRsp = 5463, + CmdChessRogueStartCsReq = 5511, + CmdChessRogueGiveUpScRsp = 5481, + CmdSelectChessRogueSubStoryCsReq = 5427, + CmdChessRoguePickAvatarScRsp = 5441, + CmdChessRogueSelectCellCsReq = 5513, + CmdSyncChessRogueNousSubStoryScNotify = 5402, + CmdChessRogueQueryBpScRsp = 5479, + CmdChessRogueEnterCellScRsp = 5516, + CmdGetChessRogueStoryInfoScRsp = 5575, + CmdChessRogueUpdateActionPointScNotify = 5425, + CmdChessRogueNousDiceUpdateNotify = 5542, + CmdGetChessRogueNousStoryInfoCsReq = 5480, + CmdChessRogueGoAheadScRsp = 5529, + CmdChessRogueQuitScRsp = 5588, + CmdChessRogueQueryCsReq = 5458, + CmdFinishChessRogueNousSubStoryCsReq = 5579, + CmdChessRogueFinishCurRoomNotify = 5439, + CmdChessRogueUpdateBoardScNotify = 5515, + CmdSyncChessRogueNousMainStoryScNotify = 5419, + CmdChessRogueConfirmRollScRsp = 5428, + CmdChessRogueQueryScRsp = 5484, + CmdChessRogueGiveUpRollCsReq = 5448, + CmdChessRogueEnterNextLayerScRsp = 5582, + CmdFinishChessRogueNousSubStoryScRsp = 5560, + CmdChessRogueUpdateUnlockLevelScNotify = 5472, + CmdChessRogueUpdateMoneyInfoScNotify = 5594, + CmdSelectChessRogueNousSubStoryCsReq = 5566, + CmdChessRogueReviveAvatarCsReq = 5518, + CmdGetChessRogueStoryInfoCsReq = 5482, + CmdChessRogueUpdateAllowedSelectCellScNotify = 5464, + CmdChessRoguePickAvatarCsReq = 5495, + CmdChessRogueNousDiceSurfaceUnlockNotify = 5426, + CmdChessRogueCheatRollCsReq = 5444, + CmdChessRogueReRollDiceScRsp = 5555, + CmdChessRogueReRollDiceCsReq = 5424, + CmdSyncChessRogueNousValueScNotify = 5437, + CmdChessRogueNousEnableRogueTalentScRsp = 5449, + CmdChessRogueUpdateLevelBaseInfoScNotify = 5546, + CmdChessRogueQueryAeonDimensionsCsReq = 5510, + CmdChessRogueQuestFinishNotify = 5578, + _, +}; + +pub const NAJBNNGJKPA = enum(i32) { + CHESS_ROGUE_DICE_IDLE = 0, + CHESS_ROGUE_DICE_ROLLED = 1, + CHESS_ROGUE_DICE_CONFIRMED = 2, + CHESS_ROGUE_DICE_GIVEUP = 3, + _, +}; + +pub const MDKFCMBNFGK = enum(i32) { + CHESS_ROGUE_DICE_FIXED = 0, + CHESS_ROGUE_DICE_EDITABLE = 1, + _, +}; + +pub const NLFCJLEEOLJ = enum(i32) { + IDLE = 0, + SELECTED = 1, + PROCESSING = 2, + FINISH = 3, + _, +}; + +pub const BAKDCEGIGBP = enum(i32) { + CHESS_ROGUE_CELL_SPECIAL_TYPE_NONE = 0, + CHESS_ROGUE_CELL_SPECIAL_TYPE_LOCKED = 1, + CHESS_ROGUE_CELL_SPECIAL_TYPE_REPLICATE = 2, + CHESS_ROGUE_CELL_SPECIAL_TYPE_PROTECTED = 3, + CHESS_ROGUE_CELL_SPECIAL_TYPE_SEED = 4, + CHESS_ROGUE_CELL_SPECIAL_TYPE_STAMP = 5, + _, +}; + +pub const NMCODCECJMC = enum(i32) { + CHESS_ROGUE_LEVEL_IDLE = 0, + CHESS_ROGUE_LEVEL_PROCESSING = 1, + CHESS_ROGUE_LEVEL_PENDING = 2, + CHESS_ROGUE_LEVEL_FINISH = 3, + CHESS_ROGUE_LEVEL_FAILED = 4, + CHESS_ROGUE_LEVEL_FORCE_FINISH = 5, + _, +}; + +pub const EMNLDJGMBCA = enum(i32) { + CHESS_ROGUE_ACCOUNT_BY_NONE = 0, + CHESS_ROGUE_ACCOUNT_BY_NORMAL_FINISH = 1, + CHESS_ROGUE_ACCOUNT_BY_NORMAL_QUIT = 2, + CHESS_ROGUE_ACCOUNT_BY_DIALOG = 3, + CHESS_ROGUE_ACCOUNT_BY_FAILED = 4, + CHESS_ROGUE_ACCOUNT_BY_CUSTOM_OP = 5, + _, +}; + +pub const IHDMEDGCAGK = enum(i32) { + CHESS_ROGUE_BUFF_SOURCE_TYPE_NONE = 0, + CHESS_ROGUE_BUFF_SOURCE_TYPE_SELECT = 1, + CHESS_ROGUE_BUFF_SOURCE_TYPE_ENHANCE = 2, + CHESS_ROGUE_BUFF_SOURCE_TYPE_MIRACLE = 3, + CHESS_ROGUE_BUFF_SOURCE_TYPE_DIALOGUE = 4, + CHESS_ROGUE_BUFF_SOURCE_TYPE_BONUS = 5, + CHESS_ROGUE_BUFF_SOURCE_TYPE_SHOP = 6, + CHESS_ROGUE_BUFF_SOURCE_TYPE_DICE = 7, + CHESS_ROGUE_BUFF_SOURCE_TYPE_AEON = 8, + CHESS_ROGUE_BUFF_SOURCE_TYPE_MAZE_SKILL = 9, + CHESS_ROGUE_BUFF_SOURCE_TYPE_LEVEL_MECHANISM = 10, + _, +}; + +pub const PHMMMHLKIKK = enum(i32) { + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_NONE = 0, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_SELECT = 1, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_DIALOGUE = 2, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_BONUS = 3, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_USE = 4, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_RESET = 5, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_REPLACE = 6, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_TRADE = 7, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_GET = 8, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_SHOP = 9, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_MAZE_SKILL = 10, + CHESS_ROGUE_MIRACLE_SOURCE_TYPE_LEVEL_MECHANISM = 11, + _, +}; + +pub const BAELJKMHLBH = enum(i32) { + CHESS_ROGUE_UPDATE_LEVEL_STATUS_BY_NONE = 0, + CHESS_ROGUE_UPDATE_LEVEL_STATUS_BY_DIALOG = 1, + _, +}; + +pub const PCHMJNLPBGF = enum(i32) { + CHESS_ROGUE_CELL_UPDATE_REASON_NONE = 0, + CHESS_ROGUE_CELL_UPDATE_REASON_MODIFIER = 1, + _, +}; + +pub const IDCPLKFBCDI = enum(i32) { + CHESS_ROGUE_AEON_TYPE_NONE = 0, + CHESS_ROGUE_AEON_TYPE_KNIGHT = 1, + CHESS_ROGUE_AEON_TYPE_MEMORY = 2, + CHESS_ROGUE_AEON_TYPE_WARLOCK = 3, + CHESS_ROGUE_AEON_TYPE_PRIEST = 4, + CHESS_ROGUE_AEON_TYPE_ROGUE = 5, + CHESS_ROGUE_AEON_TYPE_WARRIOR = 6, + CHESS_ROGUE_AEON_TYPE_HAPPY = 7, + CHESS_ROGUE_AEON_TYPE_BREED = 8, + _, +}; + +pub const NKFKCONCMMA = enum(i32) { + CHESS_ROGUE_DICE_SOURCE_TYPE_NONE = 0, + CHESS_ROGUE_DICE_SOURCE_TYPE_NORMAL = 1, + CHESS_ROGUE_DICE_SOURCE_TYPE_REPEAT = 2, + CHESS_ROGUE_DICE_SOURCE_TYPE_CHEAT = 3, + _, +}; + +pub const PIJHHJMCMGL = enum(i32) { + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_NONE = 0, + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_UNLOCK = 1, + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_FINISH = 2, + CHESS_ROGUE_NOUS_MAIN_STORY_STATUS_CAN_TRIGGER = 3, + _, +}; + +pub const NEKIHOHLNFP = enum(i32) { + NONE = 0, + PHASE_ONE = 1, + PHASE_TWO = 2, + _, +}; + +pub const MIEMKPPLBLI = enum(i32) { + CmdClockParkTypeNone = 0, + CmdClockParkBattleEndScNotify = 7291, + CmdClockParkStartScriptScRsp = 7241, + CmdClockParkHandleWaitOperationCsReq = 7289, + CmdClockParkGetInfoScRsp = 7274, + CmdClockParkGetInfoCsReq = 7218, + CmdClockParkQuitScriptCsReq = 7246, + CmdClockParkHandleWaitOperationScRsp = 7257, + CmdClockParkUseBuffCsReq = 7240, + CmdClockParkGetOngoingScriptInfoCsReq = 7219, + CmdClockParkStartScriptCsReq = 7228, + CmdClockParkUseBuffScRsp = 7248, + CmdClockParkGetOngoingScriptInfoScRsp = 7264, + CmdClockParkUnlockTalentScRsp = 7249, + CmdClockParkQuitScriptScRsp = 7298, + CmdClockParkFinishScriptScNotify = 7273, + CmdClockParkUnlockTalentCsReq = 7258, + _, +}; + +pub const PBLABLACIPO = enum(i32) { + CLOCK_PARK_PLAY_NONE = 0, + CLOCK_PARK_PLAY_NORMAL_DEATH = 1, + CLOCK_PARK_PLAY_NORMAL_PASS = 2, + CLOCK_PARK_PLAY_FINISH_SCRIPT = 5, + _, +}; + +pub const MissionStatus = enum(i32) { + MISSION_NONE = 0, + MISSION_DOING = 1, + MISSION_FINISH = 2, + MISSION_PREPARED = 3, + _, +}; + +pub const MessageSectionStatus = enum(i32) { + MESSAGE_SECTION_NONE = 0, + MESSAGE_SECTION_DOING = 1, + MESSAGE_SECTION_FINISH = 2, + MESSAGE_SECTION_FROZEN = 3, + _, +}; + +pub const MessageGroupStatus = enum(i32) { + MESSAGE_GROUP_NONE = 0, + MESSAGE_GROUP_DOING = 1, + MESSAGE_GROUP_FINISH = 2, + MESSAGE_GROUP_FROZEN = 3, + _, +}; + +pub const JLMBAEKILPG = enum(i32) { + BATTLE_RECORD_NONE = 0, + BATTLE_RECORD_CHALLENGE = 1, + BATTLE_RECORD_ROGUE = 2, + _, +}; + +pub const OICCDGCAPKG = enum(i32) { + REBATTLE_TYPE_NONE = 0, + REBATTLE_TYPE_REBATTLE_MIDWAY = 1, + REBATTLE_TYPE_REBATTLE_LOSE = 2, + REBATTLE_TYPE_REBATTLE_MIDWAY_LINEUP = 3, + REBATTLE_TYPE_REBATTLE_LOSE_LINEUP = 4, + REBATTLE_TYPE_QUIT_MIDWAY = 5, + REBATTLE_TYPE_QUIT_LOSE = 6, + _, +}; + +pub const KLKCMAPNOGA = enum(i32) { + ContentPackageStatus_None = 0, + ContentPackageStatus_Init = 1, + ContentPackageStatus_Doing = 2, + ContentPackageStatus_Finished = 3, + ContentPackageStatus_Release = 4, + _, +}; + +pub const JKHGPFPAOOM = enum(i32) { + CmdContentPackageTypeNone = 0, + CmdContentPackageGetDataCsReq = 7519, + CmdContentPackageSyncDataScNotify = 7506, + CmdContentPackageUnlockScRsp = 7537, + CmdContentPackageUnlockCsReq = 7545, + CmdContentPackageTransferScNotify = 7520, + CmdContentPackageGetDataScRsp = 7529, + _, +}; + +pub const KGOPPKFGKPC = enum(i32) { + CmdDailyActiveTypeNone = 0, + CmdDailyActiveInfoNotify = 3358, + CmdTakeApRewardScRsp = 3374, + CmdTakeAllApRewardCsReq = 3349, + CmdTakeApRewardCsReq = 3318, + CmdGetDailyActiveInfoScRsp = 3337, + CmdTakeAllApRewardScRsp = 3328, + CmdGetDailyActiveInfoCsReq = 3329, + _, +}; + +pub const MCHPAAFLLJC = enum(i32) { + CmdDrinkMakerTypeNone = 0, + CmdMakeMissionDrinkCsReq = 6989, + CmdDrinkMakerChallengeScRsp = 6981, + CmdGetDrinkMakerDataCsReq = 6994, + CmdDrinkMakerChallengeCsReq = 6999, + CmdMakeDrinkCsReq = 6993, + CmdEndDrinkMakerSequenceCsReq = 6983, + CmdDrinkMakerUpdateTipsNotify = 6990, + CmdMakeMissionDrinkScRsp = 6986, + CmdGetDrinkMakerDataScRsp = 6997, + CmdEndDrinkMakerSequenceScRsp = 6984, + CmdDrinkMakerDayEndScNotify = 6992, + CmdMakeDrinkScRsp = 6985, + _, +}; + +pub const OCKDBGADNAK = enum(i32) { + CmdEvolveBuildNone = 0, + CmdEvolveBuildQueryInfoScRsp = 7129, + CmdEvolveBuildStartStageScRsp = 7120, + CmdEvolveBuildStartStageCsReq = 7137, + CmdEvolveBuildGiveupCsReq = 7112, + CmdEvolveBuildLeaveScRsp = 7150, + CmdEvolveBuildShopAbilityDownCsReq = 7124, + CmdEvolveBuildReRandomStageCsReq = 7105, + CmdEvolveBuildStartLevelCsReq = 7106, + CmdEvolveBuildShopAbilityUpScRsp = 7131, + CmdEvolveBuildTakeExpRewardCsReq = 7148, + CmdEvolveBuildUnlockInfoNotify = 7123, + CmdEvolveBuildCoinNotify = 7139, + CmdEvolveBuildFinishScNotify = 7101, + CmdEvolveBuildGiveupScRsp = 7121, + CmdEvolveBuildShopAbilityUpCsReq = 7113, + CmdEvolveBuildShopAbilityResetCsReq = 7117, + CmdEvolveBuildTakeExpRewardScRsp = 7144, + CmdEvolveBuildQueryInfoCsReq = 7119, + CmdEvolveBuildShopAbilityDownScRsp = 7116, + CmdEvolveBuildReRandomStageScRsp = 7103, + CmdEvolveBuildStartLevelScRsp = 7145, + CmdEvolveBuildShopAbilityResetScRsp = 7149, + CmdEvolveBuildLeaveCsReq = 7109, + _, +}; + +pub const IHOAKOAHIJC = enum(i32) { + EVOLVE_PERIOD_NONE = 0, + EVOLVE_PERIOD_FIRST = 1, + EVOLVE_PERIOD_SECOND = 2, + EVOLVE_PERIOD_THIRD = 3, + EVOLVE_PERIOD_EXTRA = 4, + _, +}; + +pub const GADPGIMLECD = enum(i32) { + EVOLVE_BATTLE_RESULT_NONE = 0, + EVOLVE_BATTLE_RESULT_WIN = 1, + EVOLVE_BATTLE_RESULT_ALL_AVATAR_DEAD = 2, + EVOLVE_BATTLE_RESULT_NO_DEAD_LINE = 3, + EVOLVE_BATTLE_RESULT_QUIT = 4, + _, +}; + +pub const CmdExpeditionType = enum(i32) { + CmdExpeditionTypeNone = 0, + CmdTakeMultipleExpeditionRewardCsReq = 2562, + CmdCancelExpeditionCsReq = 2558, + CmdAcceptMultipleExpeditionScRsp = 2591, + CmdTakeMultipleExpeditionRewardScRsp = 2540, + CmdAcceptActivityExpeditionCsReq = 2564, + CmdGetExpeditionDataCsReq = 2518, + CmdCancelActivityExpeditionCsReq = 2557, + CmdAcceptExpeditionScRsp = 2537, + CmdCancelExpeditionScRsp = 2549, + CmdAcceptMultipleExpeditionCsReq = 2522, + CmdExpeditionDataChangeScNotify = 2519, + CmdTakeActivityExpeditionRewardScRsp = 2583, + CmdTakeExpeditionRewardCsReq = 2528, + CmdCancelActivityExpeditionScRsp = 2546, + CmdAcceptExpeditionCsReq = 2529, + CmdAcceptActivityExpeditionScRsp = 2589, + CmdTakeActivityExpeditionRewardCsReq = 2598, + CmdTakeExpeditionRewardScRsp = 2541, + CmdGetExpeditionDataScRsp = 2574, + _, +}; + +pub const EHAHAPCHHFP = enum(i32) { + CmdFantasticStoryActivityTypeNone = 0, + CmdEnterFantasticStoryActivityStageScRsp = 4958, + CmdEnterFantasticStoryActivityStageCsReq = 4937, + CmdFinishChapterScNotify = 4929, + CmdGetFantasticStoryActivityDataCsReq = 4918, + CmdGetFantasticStoryActivityDataScRsp = 4974, + CmdFantasticStoryActivityBattleEndScNotify = 4949, + _, +}; + +pub const CMCAIOFNGDM = enum(i32) { + CmdFeverTimeActivityTypeNone = 0, + CmdFeverTimeActivityBattleEndScNotify = 7157, + CmdEnterFeverTimeActivityStageCsReq = 7152, + CmdGetFeverTimeActivityDataCsReq = 7160, + CmdGetFeverTimeActivityDataScRsp = 7156, + CmdEnterFeverTimeActivityStageScRsp = 7155, + _, +}; + +pub const NEHPFBIGJCP = enum(i32) { + FEVER_TIME_BATTLE_RANK_C = 0, + FEVER_TIME_BATTLE_RANK_B = 1, + FEVER_TIME_BATTLE_RANK_A = 2, + FEVER_TIME_BATTLE_RANK_S = 3, + FEVER_TIME_BATTLE_RANK_SS = 4, + _, +}; + +pub const CDCAGDHICAP = enum(i32) { + CmdFightTypeNone = 0, + CmdFightLeaveScNotify = 30029, + CmdFightHeartBeatCsReq = 30058, + CmdFightEnterScRsp = 30074, + CmdFightHeartBeatScRsp = 30049, + CmdFightKickOutScNotify = 30037, + CmdFightEnterCsReq = 30018, + CmdFightSessionStopScNotify = 30028, + _, +}; + +pub const HBBIGFGOBGP = enum(i32) { + CmdFightActivityTypeNone = 0, + CmdGetFightActivityDataCsReq = 3618, + CmdEnterFightActivityStageCsReq = 3637, + CmdGetFightActivityDataScRsp = 3674, + CmdEnterFightActivityStageScRsp = 3658, + CmdFightActivityDataChangeScNotify = 3629, + CmdTakeFightActivityRewardCsReq = 3649, + CmdTakeFightActivityRewardScRsp = 3628, + _, +}; + +pub const ALBNOHEAJIJ = enum(i32) { + CmdFightMathc3TypeNone = 0, + CmdFightMatch3DataScRsp = 30174, + CmdFightMatch3StartCountDownScNotify = 30129, + CmdFightMatch3ChatScNotify = 30189, + CmdFightMatch3SwapCsReq = 30149, + CmdFightMatch3ChatCsReq = 30119, + CmdFightMatch3TurnStartScNotify = 30137, + CmdFightMatch3SwapScRsp = 30128, + CmdFightMatch3ChatScRsp = 30164, + CmdFightMatch3ForceUpdateNotify = 30157, + CmdFightMatch3TurnEndScNotify = 30158, + CmdFightMatch3DataCsReq = 30118, + CmdFightMatch3OpponentDataScNotify = 30141, + _, +}; + +pub const DONOGLEODAJ = enum(i32) { + MATCH3_STATE_IDLE = 0, + MATCH3_STATE_START = 1, + MATCH3_STATE_MATCH = 2, + MATCH3_STATE_GAME = 3, + MATCH3_STATE_HALFTIME = 4, + MATCH3_STATE_OVER = 5, + _, +}; + +pub const FMBMMKCIELK = enum(i32) { + MATCH3_PLAYER_STATE_ALIVE = 0, + MATCH3_PLAYER_STATE_DYING = 1, + MATCH3_PLAYER_STATE_DEAD = 2, + MATCH3_PLAYER_STATE_LEAVE = 3, + _, +}; + +pub const FEOEOFGGCLE = enum(i32) { + EVENT_BEGIN = 0, + EVENT_BREAK = 1, + EVENT_FALL = 2, + EVENT_REFRESH = 3, + EVENT_BIRD_SKILL = 4, + EVENT_ENV = 5, + EVENT_SHUFFLE = 6, + EVENT_SETTLE_TAG = 7, + _, +}; + +pub const IBJPLBNECEG = enum(i32) { + CmdFriendTypeNone = 0, + CmdGetPlayerDetailInfoCsReq = 2929, + CmdGetFriendChallengeDetailCsReq = 2910, + CmdGetPlatformPlayerInfoScRsp = 2939, + CmdGetAssistListCsReq = 2961, + CmdSetFriendMarkCsReq = 2942, + CmdTakeAssistRewardCsReq = 2970, + CmdGetFriendBattleRecordDetailCsReq = 2968, + CmdGetFriendDevelopmentInfoScRsp = 2967, + CmdGetFriendLoginInfoScRsp = 2975, + CmdGetFriendLoginInfoCsReq = 2914, + CmdNewAssistHistoryNotify = 2906, + CmdGetAssistHistoryCsReq = 2909, + CmdGetFriendRecommendListInfoScRsp = 2948, + CmdApplyFriendScRsp = 2941, + CmdSetForbidOtherApplyFriendCsReq = 2953, + CmdSyncHandleFriendScNotify = 2957, + CmdSetFriendRemarkNameScRsp = 2908, + CmdSetFriendMarkScRsp = 2945, + CmdGetCurAssistScRsp = 2913, + CmdDeleteBlacklistScRsp = 2924, + CmdSearchPlayerScRsp = 2947, + CmdSetFriendRemarkNameCsReq = 2973, + CmdGetFriendListInfoCsReq = 2918, + CmdTakeAssistRewardScRsp = 2980, + CmdSearchPlayerCsReq = 2992, + CmdGetFriendRecommendListInfoCsReq = 2940, + CmdDeleteFriendCsReq = 2946, + CmdReportPlayerScRsp = 2921, + CmdSyncAddBlacklistScNotify = 2962, + CmdGetAssistHistoryScRsp = 2956, + CmdReportPlayerCsReq = 2911, + CmdCurAssistChangedNotify = 2923, + CmdHandleFriendCsReq = 2964, + CmdApplyFriendCsReq = 2928, + CmdSetForbidOtherApplyFriendScRsp = 2912, + CmdGetFriendChallengeLineupScRsp = 3000, + CmdGetPlayerDetailInfoScRsp = 2937, + CmdSetAssistScRsp = 2959, + CmdAddBlacklistScRsp = 2991, + CmdGetPlatformPlayerInfoCsReq = 2987, + CmdGetFriendChallengeDetailScRsp = 2920, + CmdGetFriendApplyListInfoCsReq = 2958, + CmdGetFriendAssistListCsReq = 2916, + CmdGetFriendDevelopmentInfoCsReq = 2990, + CmdGetFriendChallengeLineupCsReq = 2988, + CmdGetFriendApplyListInfoScRsp = 2949, + CmdAddBlacklistCsReq = 2922, + CmdGetFriendListInfoScRsp = 2974, + CmdGetFriendBattleRecordDetailScRsp = 2933, + CmdGetCurAssistCsReq = 2902, + CmdSetAssistCsReq = 2982, + CmdGetFriendAssistListScRsp = 2936, + CmdHandleFriendScRsp = 2989, + CmdDeleteBlacklistCsReq = 2977, + CmdDeleteFriendScRsp = 2998, + CmdSyncDeleteFriendScNotify = 2983, + CmdGetAssistListScRsp = 2938, + CmdSyncApplyFriendScNotify = 2919, + _, +}; + +pub const BHOFBFFAJJK = enum(i32) { + FRIEND_ONLINE_STATUS_OFFLINE = 0, + FRIEND_ONLINE_STATUS_ONLINE = 1, + _, +}; + +pub const KAMMNBKBEOL = enum(i32) { + FRIEND_APPLY_SOURCE_NONE = 0, + FRIEND_APPLY_SOURCE_SEARCH = 1, + FRIEND_APPLY_SOURCE_RECOMMEND = 2, + FRIEND_APPLY_SOURCE_ASSIST = 3, + FRIEND_APPLY_SOURCE_RECOMMEND_ASSIST = 4, + FRIEND_APPLY_SOURCE_PSN_FRIEND = 5, + FRIEND_APPLY_SOURCE_ASSIST_REWARD = 6, + _, +}; + +pub const CmdGachaType = enum(i32) { + CmdGachaTypeNone = 0, + CmdDoGachaScRsp = 1937, + CmdExchangeGachaCeilingScRsp = 1941, + CmdGetGachaCeilingScRsp = 1949, + CmdGetGachaInfoScRsp = 1974, + CmdExchangeGachaCeilingCsReq = 1928, + CmdGetGachaCeilingCsReq = 1958, + CmdDoGachaCsReq = 1929, + CmdGetGachaInfoCsReq = 1918, + _, +}; + +pub const DJNPONCMBAJ = enum(i32) { + CmdHeartdialTypeNone = 0, + CmdFinishEmotionDialoguePerformanceScRsp = 6341, + CmdGetHeartDialInfoScRsp = 6374, + CmdHeartDialScriptChangeScNotify = 6319, + CmdSubmitEmotionItemScRsp = 6349, + CmdSubmitEmotionItemCsReq = 6358, + CmdHeartDialTraceScriptScRsp = 6389, + CmdHeartDialTraceScriptCsReq = 6364, + CmdGetHeartDialInfoCsReq = 6318, + CmdChangeScriptEmotionCsReq = 6329, + CmdChangeScriptEmotionScRsp = 6337, + CmdFinishEmotionDialoguePerformanceCsReq = 6328, + _, +}; + +pub const ECLMHPDLLPN = enum(i32) { + HEART_DIAL_EMOTION_TYPE_PEACE = 0, + HEART_DIAL_EMOTION_TYPE_ANGER = 1, + HEART_DIAL_EMOTION_TYPE_HAPPY = 2, + HEART_DIAL_EMOTION_TYPE_SAD = 3, + _, +}; + +pub const ALEFJKKKEGA = enum(i32) { + HEART_DIAL_STEP_TYPE_MISSING = 0, + HEART_DIAL_STEP_TYPE_FULL = 1, + HEART_DIAL_STEP_TYPE_LOCK = 2, + HEART_DIAL_STEP_TYPE_UNLOCK = 3, + HEART_DIAL_STEP_TYPE_NORMAL = 4, + HEART_DIAL_STEP_TYPE_CONTROL = 5, + _, +}; + +pub const BJGCCNNMPHI = enum(i32) { + HEART_DIAL_UNLOCK_STATUS_LOCK = 0, + HEART_DIAL_UNLOCK_STATUS_UNLOCK_SINGLE = 1, + HEART_DIAL_UNLOCK_STATUS_UNLOCK_ALL = 2, + _, +}; + +pub const IKDOLAEKINN = enum(i32) { + CmdHeliobusTypeNone = 0, + CmdHeliobusEnterBattleScRsp = 5873, + CmdHeliobusSnsReadCsReq = 5829, + CmdHeliobusActivityDataScRsp = 5874, + CmdHeliobusSnsReadScRsp = 5837, + CmdHeliobusSnsCommentCsReq = 5819, + CmdHeliobusActivityDataCsReq = 5818, + CmdHeliobusSnsLikeCsReq = 5828, + CmdHeliobusLineupUpdateScNotify = 5877, + CmdHeliobusUpgradeLevelCsReq = 5846, + CmdHeliobusSnsPostCsReq = 5858, + CmdHeliobusChallengeUpdateScNotify = 5821, + CmdHeliobusStartRaidScRsp = 5811, + CmdHeliobusUnlockSkillScNotify = 5883, + CmdHeliobusSnsLikeScRsp = 5841, + CmdHeliobusSnsPostScRsp = 5849, + CmdHeliobusInfoChangedScNotify = 5857, + CmdHeliobusEnterBattleCsReq = 5848, + CmdHeliobusSelectSkillScRsp = 5891, + CmdHeliobusUpgradeLevelScRsp = 5898, + CmdHeliobusStartRaidCsReq = 5808, + CmdHeliobusSnsUpdateScNotify = 5889, + CmdHeliobusSelectSkillCsReq = 5822, + CmdHeliobusSnsCommentScRsp = 5864, + _, +}; + +pub const CmdItemType = enum(i32) { + CmdItemTypeNone = 0, + CmdComposeSelectedRelicCsReq = 521, + CmdExpUpRelicScRsp = 522, + CmdComposeItemCsReq = 546, + CmdLockRelicScRsp = 562, + CmdRankUpEquipmentCsReq = 519, + CmdGetMarkItemListCsReq = 502, + CmdSyncTurnFoodNotify = 570, + CmdLockEquipmentCsReq = 558, + CmdExpUpRelicCsReq = 583, + CmdRelicAvatarRecommendScRsp = 542, + CmdMarkItemCsReq = 509, + CmdGetRelicFilterPlanScRsp = 516, + CmdComposeLimitNumUpdateNotify = 538, + CmdGetMarkItemListScRsp = 513, + CmdDeleteRelicFilterPlanCsReq = 520, + CmdAddRelicFilterPlanCsReq = 536, + CmdAddEquipmentScNotify = 524, + CmdComposeSelectedRelicScRsp = 577, + CmdUseItemScRsp = 541, + CmdDeleteRelicFilterPlanScRsp = 568, + CmdGetRecyleTimeCsReq = 592, + CmdComposeLimitNumCompleteNotify = 561, + CmdMarkRelicFilterPlanScRsp = 590, + CmdDestroyItemCsReq = 582, + CmdComposeItemScRsp = 598, + CmdDestroyItemScRsp = 559, + CmdUseItemCsReq = 528, + CmdMarkRelicFilterPlanCsReq = 533, + CmdRechargeSuccNotify = 573, + CmdAddRelicFilterPlanScRsp = 588, + CmdSellItemScRsp = 548, + CmdLockRelicCsReq = 591, + CmdGetBagScRsp = 574, + CmdExpUpEquipmentScRsp = 557, + CmdMarkItemScRsp = 556, + CmdRelicFilterPlanClearNameScNotify = 567, + CmdSetTurnFoodSwitchCsReq = 580, + CmdModifyRelicFilterPlanScRsp = 510, + CmdGetBagCsReq = 518, + CmdDiscardRelicCsReq = 539, + CmdSetTurnFoodSwitchScRsp = 523, + CmdPromoteEquipmentCsReq = 529, + CmdRelicRecommendCsReq = 575, + CmdSellItemCsReq = 540, + CmdGeneralVirtualItemDataNotify = 587, + CmdLockEquipmentScRsp = 549, + CmdExchangeHcoinScRsp = 511, + CmdModifyRelicFilterPlanCsReq = 600, + CmdGetRelicFilterPlanCsReq = 545, + CmdExchangeHcoinCsReq = 508, + CmdExpUpEquipmentCsReq = 589, + CmdCancelMarkItemNotify = 506, + CmdGetRecyleTimeScRsp = 547, + CmdPromoteEquipmentScRsp = 537, + CmdDiscardRelicScRsp = 514, + CmdRelicRecommendScRsp = 553, + CmdRelicAvatarRecommendCsReq = 512, + CmdRankUpEquipmentScRsp = 564, + _, +}; + +pub const DENLODKNFJE = enum(i32) { + TURN_FOOD_SWITCH_NONE = 0, + TURN_FOOD_SWITCH_ATTACK = 1, + TURN_FOOD_SWITCH_DEFINE = 2, + _, +}; + +pub const NEDFKJNKMDI = enum(i32) { + CmdJukeboxTypeNone = 0, + CmdGetJukeboxDataScRsp = 3174, + CmdTrialBackGroundMusicScRsp = 3141, + CmdUnlockBackGroundMusicCsReq = 3158, + CmdPlayBackGroundMusicCsReq = 3129, + CmdUnlockBackGroundMusicScRsp = 3149, + CmdTrialBackGroundMusicCsReq = 3128, + CmdPlayBackGroundMusicScRsp = 3137, + CmdGetJukeboxDataCsReq = 3118, + _, +}; + +pub const CmdLineupType = enum(i32) { + CmdLineupTypeNone = 0, + CmdQuitLineupCsReq = 728, + CmdSwapLineupCsReq = 719, + CmdGetAllLineupDataScRsp = 773, + CmdSetLineupNameCsReq = 762, + CmdChangeLineupLeaderCsReq = 798, + CmdSetLineupNameScRsp = 740, + CmdJoinLineupCsReq = 758, + CmdChangeLineupLeaderScRsp = 783, + CmdQuitLineupScRsp = 741, + CmdReplaceLineupScRsp = 721, + CmdGetStageLineupScRsp = 774, + CmdVirtualLineupDestroyNotify = 708, + CmdSwapLineupScRsp = 764, + CmdSyncLineupNotify = 789, + CmdGetLineupAvatarDataCsReq = 757, + CmdGetLineupAvatarDataScRsp = 746, + CmdGetCurLineupDataCsReq = 729, + CmdGetCurLineupDataScRsp = 737, + CmdSwitchLineupIndexCsReq = 722, + CmdReplaceLineupCsReq = 711, + CmdGetStageLineupCsReq = 718, + CmdGetAllLineupDataCsReq = 748, + CmdExtraLineupDestroyNotify = 777, + CmdSwitchLineupIndexScRsp = 791, + CmdJoinLineupScRsp = 749, + _, +}; + +pub const AMECGBOCMAE = enum(i32) { + LINEUP_TYPE_NONE = 0, + LINEUP_TYPE_PRESET = 1, + LINEUP_TYPE_VIRTUAL = 2, + LINEUP_TYPE_EXTRA = 3, + LINEUP_TYPE_STORY_LINE = 4, + _, +}; + +pub const ExtraLineupType = enum(i32) { + LINEUP_NONE = 0, + LINEUP_CHALLENGE = 1, + LINEUP_ROGUE = 2, + LINEUP_CHALLENGE_2 = 3, + LINEUP_CHALLENGE_3 = 4, + LINEUP_ROGUE_CHALLENGE = 5, + LINEUP_STAGE_TRIAL = 6, + LINEUP_ROGUE_TRIAL = 7, + LINEUP_ACTIVITY = 8, + LINEUP_BOXING_CLUB = 9, + LINEUP_TREASURE_DUNGEON = 11, + LINEUP_CHESS_ROGUE = 12, + LINEUP_HELIOBUS = 13, + LINEUP_TOURN_ROGUE = 14, + LINEUP_RELIC_ROGUE = 15, + _, +}; + +pub const SyncLineupReason = enum(i32) { + SYNC_REASON_NONE = 0, + SYNC_REASON_MP_ADD = 1, + SYNC_REASON_MP_ADD_PROP_HIT = 2, + SYNC_REASON_HP_ADD = 3, + SYNC_REASON_HP_ADD_PROP_HIT = 4, + _, +}; + +pub const DAKJJGNBPIA = enum(i32) { + CmdLobbyTypeNone = 0, + CmdLobbySyncInfoScNotify = 7351, + CmdLobbyGetInfoScRsp = 7374, + CmdLobbyQuitScRsp = 7360, + CmdLobbyCreateScRsp = 7379, + CmdLobbyQuitCsReq = 7391, + CmdLobbyInviteScRsp = 7353, + CmdLobbyGetInfoCsReq = 7381, + CmdLobbyInviteCsReq = 7355, + CmdLobbyModifyPlayerInfoCsReq = 7362, + CmdLobbyJoinScRsp = 7395, + CmdLobbyBeginScRsp = 7370, + CmdLobbyJoinCsReq = 7356, + CmdLobbyKickOutCsReq = 7359, + CmdLobbyBeginCsReq = 7387, + CmdLobbyKickOutScRsp = 7400, + CmdLobbyInviteScNotify = 7363, + CmdLobbyCreateCsReq = 7369, + CmdLobbyModifyPlayerInfoScRsp = 7371, + _, +}; + +pub const CmdMailType = enum(i32) { + CmdMailTypeNone = 0, + CmdMarkReadMailCsReq = 829, + CmdTakeMailAttachmentScRsp = 841, + CmdNewMailScNotify = 819, + CmdMarkReadMailScRsp = 837, + CmdGetMailScRsp = 874, + CmdGetMailCsReq = 818, + CmdDelMailScRsp = 849, + CmdDelMailCsReq = 858, + CmdTakeMailAttachmentCsReq = 828, + _, +}; + +pub const FNAIBDHKPEI = enum(i32) { + MAIL_TYPE_NORMAL = 0, + MAIL_TYPE_STAR = 1, + _, +}; + +pub const MINDJILOKDH = enum(i32) { + CmdMapRotationTypeNone = 0, + CmdInteractChargerScRsp = 6837, + CmdDeployRotaterCsReq = 6858, + CmdEnterMapRotationRegionScRsp = 6874, + CmdGetMapRotationDataScRsp = 6857, + CmdEnterMapRotationRegionCsReq = 6818, + CmdRotateMapScRsp = 6841, + CmdGetMapRotationDataCsReq = 6889, + CmdRotateMapCsReq = 6828, + CmdRemoveRotaterCsReq = 6862, + CmdLeaveMapRotationRegionCsReq = 6819, + CmdRemoveRotaterScRsp = 6840, + CmdInteractChargerCsReq = 6829, + CmdUpdateEnergyScNotify = 6822, + CmdUpdateMapRotationDataScNotify = 6891, + CmdDeployRotaterScRsp = 6849, + CmdLeaveMapRotationRegionScNotify = 6883, + CmdResetMapRotationRegionScRsp = 6898, + CmdUpdateRotaterScNotify = 6848, + CmdLeaveMapRotationRegionScRsp = 6864, + CmdResetMapRotationRegionCsReq = 6846, + _, +}; + +pub const KEBMHPFGEEG = enum(i32) { + CmdMatchTypeNone = 0, + CmdStartMatchCsReq = 7319, + CmdStartMatchScRsp = 7329, + CmdGetCrossInfoCsReq = 7320, + CmdGetCrossInfoScRsp = 7312, + CmdMatchResultScNotify = 7337, + CmdCancelMatchScRsp = 7345, + CmdCancelMatchCsReq = 7306, + _, +}; + +pub const POGDPJMAMBG = enum(i32) { + CmdMatchThreeModuleTypeNone = 0, + CmdMatchThreeSyncDataScNotify = 7437, + CmdMatchThreeGetDataScRsp = 7429, + CmdMatchThreeLevelEndCsReq = 7406, + CmdMatchThreeSetBirdPosScRsp = 7412, + CmdMatchThreeLevelEndScRsp = 7445, + CmdMatchThreeSetBirdPosCsReq = 7420, + CmdMatchThreeGetDataCsReq = 7419, + _, +}; + +pub const FPCOACKPCDG = enum(i32) { + MatchThreeStatistics_None = 0, + MatchThreeStatistics_First = 1, + MatchThreeStatistics_Second = 2, + MatchThreeStatistics_Third = 3, + MatchThreeStatistics_Fruit = 4, + MatchThreeStatistics_Skill = 5, + MatchThreeStatistics_Defeat = 6, + MatchThreeStatistics_Bomb = 7, + MatchThreeStatistics_Damage = 8, + MatchThreeStatistics_Energy = 9, + MatchThreeStatistics_SwapBomb = 10, + _, +}; + +pub const CmdMessageType = enum(i32) { + CmdMessageTypeNone = 0, + CmdFinishSectionIdCsReq = 2728, + CmdFinishPerformSectionIdCsReq = 2719, + CmdGetNpcStatusCsReq = 2729, + CmdFinishPerformSectionIdScRsp = 2764, + CmdGetNpcStatusScRsp = 2737, + CmdFinishItemIdScRsp = 2749, + CmdFinishSectionIdScRsp = 2741, + CmdFinishItemIdCsReq = 2758, + CmdGetNpcMessageGroupScRsp = 2774, + CmdGetNpcMessageGroupCsReq = 2718, + _, +}; + +pub const GFLAKGNAKBF = enum(i32) { + CmdMiscModuleTypeNone = 0, + CmdGetShareDataCsReq = 4129, + CmdSubmitOrigamiItemCsReq = 4183, + CmdShareCsReq = 4118, + CmdGetMovieRacingDataScRsp = 4108, + CmdCancelCacheNotifyCsReq = 4119, + CmdSecurityReportCsReq = 4189, + CmdTriggerVoiceScRsp = 4198, + CmdSubmitOrigamiItemScRsp = 4122, + CmdGetMovieRacingDataCsReq = 4173, + CmdShareScRsp = 4174, + CmdGetGunPlayDataScRsp = 4124, + CmdTriggerVoiceCsReq = 4146, + CmdGetShareDataScRsp = 4137, + CmdTakePictureCsReq = 4158, + CmdGetGunPlayDataCsReq = 4177, + CmdUpdateMovieRacingDataCsReq = 4111, + CmdUpdateGunPlayDataCsReq = 4192, + CmdCancelCacheNotifyScRsp = 4164, + CmdTakePictureScRsp = 4149, + CmdUpdateMovieRacingDataScRsp = 4121, + CmdUpdateGunPlayDataScRsp = 4147, + CmdSecurityReportScRsp = 4157, + _, +}; + +pub const HDCNOKOKDHC = enum(i32) { + CACHE_NOTIFY_TYPE_NONE = 0, + CACHE_NOTIFY_TYPE_RECYCLE = 1, + CACHE_NOTIFY_TYPE_RECHARGE = 2, + _, +}; + +pub const HBHPONEOFGF = enum(i32) { + MOVIE_RACING_OVER_TAKE = 0, + MOVIE_RACING_OVER_TAKE_ENDLESS = 1, + MOVIE_RACING_SHOOTING = 2, + MOVIE_RACING_SHOOTING_ENDLESS = 3, + _, +}; + +pub const CmdMissionType = enum(i32) { + CmdMissionTypeNone = 0, + CmdSetMissionEventProgressCsReq = 1221, + CmdFinishCosumeItemMissionScRsp = 1298, + CmdGetMissionEventDataCsReq = 1283, + CmdGetMainMissionCustomValueScRsp = 1213, + CmdUpdateTrackMainMissionIdScRsp = 1270, + CmdStartFinishMainMissionScNotify = 1238, + CmdSyncTaskScRsp = 1228, + CmdAcceptMainMissionScRsp = 1259, + CmdAcceptMissionEventCsReq = 1262, + CmdStartFinishSubMissionScNotify = 1261, + CmdGetMainMissionCustomValueCsReq = 1202, + CmdInterruptMissionEventCsReq = 1208, + CmdFinishTalkMissionCsReq = 1229, + CmdMissionAcceptScNotify = 1209, + CmdAcceptMainMissionCsReq = 1282, + CmdAcceptMissionEventScRsp = 1240, + CmdTeleportToMissionResetPointCsReq = 1292, + CmdMissionRewardScNotify = 1258, + CmdSyncTaskCsReq = 1249, + CmdGetMissionDataCsReq = 1218, + CmdInterruptMissionEventScRsp = 1211, + CmdFinishTalkMissionScRsp = 1237, + CmdGetMissionStatusCsReq = 1248, + CmdTeleportToMissionResetPointScRsp = 1247, + CmdFinishCosumeItemMissionCsReq = 1246, + CmdGetMissionStatusScRsp = 1273, + CmdSetMissionEventProgressScRsp = 1277, + CmdDailyTaskDataScNotify = 1241, + CmdMissionGroupWarnScNotify = 1257, + CmdGetMissionEventDataScRsp = 1222, + CmdSubMissionRewardScNotify = 1224, + CmdMissionEventRewardScNotify = 1291, + CmdUpdateTrackMainMissionIdCsReq = 1206, + CmdGetMissionDataScRsp = 1274, + _, +}; + +pub const DHELEBHIKCD = enum(i32) { + MISSION_SYNC_RECORD_NONE = 0, + MISSION_SYNC_RECORD_MAIN_MISSION_ACCEPT = 1, + MISSION_SYNC_RECORD_MAIN_MISSION_START = 2, + MISSION_SYNC_RECORD_MAIN_MISSION_FINISH = 3, + MISSION_SYNC_RECORD_MAIN_MISSION_DELETE = 4, + MISSION_SYNC_RECORD_MISSION_ACCEPT = 11, + MISSION_SYNC_RECORD_MISSION_START = 12, + MISSION_SYNC_RECORD_MISSION_FINISH = 13, + MISSION_SYNC_RECORD_MISSION_DELETE = 14, + MISSION_SYNC_RECORD_MISSION_PROGRESS = 15, + _, +}; + +pub const MMKDKKIFLDF = enum(i32) { + MAIN_MISSION_SYNC_NONE = 0, + MAIN_MISSION_SYNC_MCV = 1, + _, +}; + +pub const MOFOCPEAPDD = enum(i32) { + TRACK_MAIN_MISSION_UPDATE_NONE = 0, + TRACK_MAIN_MISSION_UPDATE_AUTO = 1, + TRACK_MAIN_MISSION_UPDATE_MANUAL = 2, + TRACK_MAIN_MISSION_UPDATE_LOGIN_REPORT = 3, + _, +}; + +pub const BBNLMAEEOGN = enum(i32) { + CmdMonopolyTypeNone = 0, + CmdGetMbtiReportScRsp = 7090, + CmdMonopolySelectOptionCsReq = 7064, + CmdGetMbtiReportCsReq = 7033, + CmdMonopolyLikeScRsp = 7020, + CmdMonopolyGameSettleScNotify = 7059, + CmdDailyFirstEnterMonopolyActivityScRsp = 7098, + CmdMonopolyDailySettleScNotify = 7036, + CmdMonopolyConfirmRandomScRsp = 7048, + CmdMonopolyRollDiceScRsp = 7028, + CmdMonopolyCheatDiceCsReq = 7092, + CmdMonopolyGameRaiseRatioScRsp = 7082, + CmdMonopolyScrachRaffleTicketScRsp = 7071, + CmdMonopolyGetRegionProgressScRsp = 7054, + CmdMonopolyGuessChooseCsReq = 7023, + CmdMonopolyClickCellCsReq = 7035, + CmdMonopolyGameRaiseRatioCsReq = 7038, + CmdMonopolyAcceptQuizCsReq = 7006, + CmdMonopolyLikeCsReq = 7010, + CmdDeleteSocialEventServerCacheCsReq = 7084, + CmdMonopolyGetRegionProgressCsReq = 7095, + CmdGetMonopolyDailyReportScRsp = 7052, + CmdMonopolyCellUpdateNotify = 7037, + CmdMonopolyContentUpdateScNotify = 7061, + CmdMonopolyGetRaffleTicketCsReq = 7001, + CmdMonopolyEventLoadUpdateScNotify = 7093, + CmdMonopolyLikeScNotify = 7068, + CmdMonopolyGiveUpCurContentScRsp = 7024, + CmdMonopolyGuessDrawScNotify = 7075, + CmdMonopolyRollRandomScRsp = 7022, + CmdMonopolyClickMbtiReportScRsp = 7055, + CmdMonopolyGuessBuyInformationScRsp = 7014, + CmdMonopolyClickCellScRsp = 7069, + CmdGetMonopolyMbtiReportRewardCsReq = 7026, + CmdMonopolyEventSelectFriendScRsp = 7003, + CmdMonopolySelectOptionScRsp = 7089, + CmdMonopolyEventSelectFriendCsReq = 7067, + CmdMonopolyReRollRandomScRsp = 7062, + CmdMonopolyAcceptQuizScRsp = 7070, + CmdDailyFirstEnterMonopolyActivityCsReq = 7046, + CmdMonopolyGuessChooseScRsp = 7087, + CmdMonopolyTakePhaseRewardScRsp = 7085, + CmdDeleteSocialEventServerCacheScRsp = 7076, + CmdMonopolyGiveUpCurContentCsReq = 7077, + CmdGetSocialEventServerCacheCsReq = 7094, + CmdMonopolyClickMbtiReportCsReq = 7066, + CmdMonopolyMoveCsReq = 7041, + CmdMonopolyGetDailyInitItemScRsp = 7060, + CmdMonopolyGameGachaCsReq = 7002, + CmdMonopolyBuyGoodsCsReq = 7073, + CmdMonopolyScrachRaffleTicketCsReq = 7081, + CmdMonopolyRollRandomCsReq = 7083, + CmdGetMonopolyDailyReportCsReq = 7030, + CmdMonopolyGetRafflePoolInfoScRsp = 7065, + CmdMonopolyTakePhaseRewardCsReq = 7099, + CmdMonopolySocialEventEffectScNotify = 7032, + CmdMonopolyBuyGoodsScRsp = 7008, + CmdGetMonopolyInfoScRsp = 7074, + CmdGetSocialEventServerCacheScRsp = 7078, + CmdMonopolyGetDailyInitItemCsReq = 7044, + CmdMonopolyQuizDurationChangeScNotify = 7053, + CmdMonopolyCheatDiceScRsp = 7047, + CmdGetMonopolyFriendRankingListScRsp = 7100, + CmdMonopolyReRollRandomCsReq = 7091, + CmdGetMonopolyMbtiReportRewardScRsp = 7086, + CmdMonopolyActionResultScNotify = 7029, + CmdMonopolyGameBingoFlipCardScRsp = 7056, + CmdMonopolyConditionUpdateScNotify = 7097, + CmdMonopolyGameGachaScRsp = 7013, + CmdMonopolyGetRaffleTicketScRsp = 7034, + CmdMonopolyTakeRaffleTicketRewardCsReq = 7017, + CmdMonopolyGetRafflePoolInfoCsReq = 7031, + CmdMonopolySttUpdateScNotify = 7005, + CmdMonopolyMoveScRsp = 7019, + CmdMonopolyGameCreateScNotify = 7080, + CmdMonopolyRollDiceCsReq = 7049, + CmdMonopolyTakeRaffleTicketRewardScRsp = 7051, + CmdGetMonopolyFriendRankingListCsReq = 7088, + CmdMonopolyGuessBuyInformationCsReq = 7039, + CmdMonopolyConfirmRandomCsReq = 7040, + CmdMonopolyGameBingoFlipCardCsReq = 7009, + CmdGetMonopolyInfoCsReq = 7018, + CmdMonopolyUpgradeAssetScRsp = 7021, + CmdMonopolyUpgradeAssetCsReq = 7011, + _, +}; + +pub const FBLFGOBDMKD = enum(i32) { + MONOPOLY_SOCIAL_EVENT_STATUS_NONE = 0, + MONOPOLY_SOCIAL_EVENT_STATUS_WAITING_SELECT_FRIEND = 1, + _, +}; + +pub const OAFMCJJFPHO = enum(i32) { + MONOPOLY_CELL_STATE_IDLE = 0, + MONOPOLY_CELL_STATE_BARRIER = 1, + MONOPOLY_CELL_STATE_GROUND = 2, + MONOPOLY_CELL_STATE_FINISH = 3, + _, +}; + +pub const BHGKIJGANCM = enum(i32) { + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_NONE = 0, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_EFFECT = 1, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_ASSET_BONUS = 2, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_ASSET_TAX = 3, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_ASSET_UPGRADE = 4, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_GAME_SETTLE = 5, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_BUY_GOODS = 6, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_CLICK = 7, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_SOCIAL_EVENT = 8, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_LIKE = 9, + MONOPOLY_ACTION_RESULT_SOURCE_TYPE_QUIZ_GAME_SETTLE = 10, + _, +}; + +pub const IGKEOKEGCHC = enum(i32) { + CmdMultiplayerTypeNone = 0, + CmdMultiplayerFightGiveUpCsReq = 1058, + CmdMultiplayerFightGiveUpScRsp = 1049, + CmdMultiplayerGetFightGateCsReq = 1029, + CmdMultiplayerMatch3FinishScNotify = 1019, + CmdMultiplayerFightGameStateScRsp = 1074, + CmdMultiplayerFightGameStateCsReq = 1018, + CmdMultiplayerFightGameFinishScNotify = 1041, + CmdMultiplayerFightGameStartScNotify = 1028, + CmdMultiplayerGetFightGateScRsp = 1037, + _, +}; + +pub const FKHDHPMGKIJ = enum(i32) { + CmdMultipleDropTypeNone = 0, + CmdGetPlayerReturnMultiDropInfoCsReq = 4637, + CmdGetPlayerReturnMultiDropInfoScRsp = 4658, + CmdMultipleDropInfoNotify = 4649, + CmdGetMultipleDropInfoCsReq = 4618, + CmdGetMultipleDropInfoScRsp = 4674, + CmdMultipleDropInfoScNotify = 4629, + _, +}; + +pub const KILIPMDEIHO = enum(i32) { + CmdMuseumTypeNone = 0, + CmdSetStuffToAreaCsReq = 4358, + CmdBuyNpcStuffScRsp = 4337, + CmdUpgradeAreaScRsp = 4398, + CmdMuseumDispatchFinishedScNotify = 4321, + CmdGetStuffScNotify = 4319, + CmdUpgradeAreaStatScRsp = 4322, + CmdMuseumTakeCollectRewardCsReq = 4347, + CmdUpgradeAreaStatCsReq = 4383, + CmdMuseumRandomEventQueryCsReq = 4348, + CmdMuseumRandomEventSelectCsReq = 4308, + CmdGetMuseumInfoCsReq = 4318, + CmdGetExhibitScNotify = 4364, + CmdSetStuffToAreaScRsp = 4349, + CmdMuseumFundsChangedScNotify = 4362, + CmdRemoveStuffFromAreaCsReq = 4328, + CmdBuyNpcStuffCsReq = 4329, + CmdFinishCurTurnCsReq = 4389, + CmdUpgradeAreaCsReq = 4346, + CmdMuseumRandomEventQueryScRsp = 4373, + CmdMuseumRandomEventSelectScRsp = 4311, + CmdMuseumTargetMissionFinishNotify = 4324, + CmdMuseumTargetRewardNotify = 4392, + CmdGetMuseumInfoScRsp = 4374, + CmdMuseumTakeCollectRewardScRsp = 4361, + CmdMuseumRandomEventStartScNotify = 4340, + CmdMuseumTargetStartNotify = 4377, + CmdFinishCurTurnScRsp = 4357, + CmdMuseumInfoChangedScNotify = 4391, + CmdRemoveStuffFromAreaScRsp = 4341, + _, +}; + +pub const OHDDKHGHJAB = enum(i32) { + MUSEUM_RANDOM_EVENT_STATE_NONE = 0, + MUSEUM_RANDOM_EVENT_STATE_START = 1, + MUSEUM_RANDOM_EVENT_STATE_PROCESSING = 2, + MUSEUM_RANDOM_EVENT_STATE_FINISH = 3, + _, +}; + +pub const BLHDECCDHDM = enum(i32) { + WORK_POS_NONE = 0, + WORK_POS_1 = 1, + WORK_POS_2 = 2, + WORK_POS_3 = 3, + _, +}; + +pub const JFLBDNGFGMD = enum(i32) { + STAT_TYPE_NONE = 0, + STAT_TYPE_ART = 1, + STAT_TYPE_CULTURE = 2, + STAT_TYPE_POPULAR = 3, + _, +}; + +pub const LMIKHOBPLCA = enum(i32) { + UNKNOW = 0, + MISSION_REWARD = 1, + EVENT_BUY_STUFF = 2, + MARKET_BUY_STUFF = 3, + QUEST_REWARD = 4, + INITIAL = 5, + PHASE_FINISH_REWARD = 6, + _, +}; + +pub const LHGGLAHCGPN = enum(i32) { + CmdOfferingTypeNone = 0, + CmdTakeOfferingRewardCsReq = 6923, + CmdOfferingInfoScNotify = 6929, + CmdGetOfferingInfoCsReq = 6934, + CmdGetOfferingInfoScRsp = 6937, + CmdSubmitOfferingItemCsReq = 6933, + CmdTakeOfferingRewardScRsp = 6924, + CmdSubmitOfferingItemScRsp = 6925, + _, +}; + +pub const MHAKLHHANJL = enum(i32) { + OFFERING_STATE_NONE = 0, + OFFERING_STATE_LOCK = 1, + OFFERING_STATE_OPEN = 2, + _, +}; + +pub const KBOOGLBELJD = enum(i32) { + CmdPamMissionTypeNone = 0, + CmdSyncAcceptedPamMissionNotify = 4029, + CmdAcceptedPamMissionExpireScRsp = 4074, + CmdAcceptedPamMissionExpireCsReq = 4018, + _, +}; + +pub const IIKFFOLLNFO = enum(i32) { + CmdPhoneTypeNone = 0, + CmdUnlockPhoneThemeScNotify = 5141, + CmdSelectChatBubbleScRsp = 5137, + CmdGetPhoneDataScRsp = 5174, + CmdUnlockChatBubbleScNotify = 5158, + CmdSelectChatBubbleCsReq = 5129, + CmdSelectPhoneThemeScRsp = 5128, + CmdSelectPhoneThemeCsReq = 5149, + CmdGetPhoneDataCsReq = 5118, + _, +}; + +pub const CmdPlayerType = enum(i32) { + CmdPlayerTypeNone = 0, + CmdSetGenderCsReq = 70, + CmdSetRedPointStatusScNotify = 17, + CmdGetBasicInfoScRsp = 45, + CmdPlayerLoginFinishScRsp = 25, + CmdSetLanguageCsReq = 47, + CmdUpdateFeatureSwitchScNotify = 12, + CmdUnlockAvatarPathScRsp = 66, + CmdGmTalkCsReq = 64, + CmdRegionStopScNotify = 62, + CmdUpdatePlayerSettingCsReq = 31, + CmdClientObjUploadCsReq = 85, + CmdAvatarPathChangedNotify = 60, + CmdSetAvatarPathCsReq = 52, + CmdPlayerLogoutCsReq = 29, + CmdStaminaInfoScNotify = 54, + CmdSetPlayerInfoScRsp = 87, + CmdGetAuthkeyCsReq = 22, + CmdSetPlayerInfoCsReq = 23, + CmdPlayerLoginFinishCsReq = 76, + CmdGateServerScNotify = 67, + CmdExchangeStaminaScRsp = 83, + CmdGetMultiPathAvatarInfoScRsp = 44, + CmdExchangeStaminaCsReq = 98, + CmdGmTalkScNotify = 41, + CmdSetGameplayBirthdayScRsp = 88, + CmdUpdatePlayerSettingScRsp = 65, + CmdGmTalkScRsp = 89, + CmdClientDownloadDataScNotify = 53, + CmdPlayerGetTokenScRsp = 49, + CmdUpdatePsnSettingsInfoCsReq = 5, + CmdGetAuthkeyScRsp = 91, + CmdServerAnnounceNotify = 38, + CmdGetLevelRewardTakenListCsReq = 8, + CmdAceAntiCheaterScRsp = 10, + CmdGetMultiPathAvatarInfoCsReq = 69, + CmdQueryProductInfoCsReq = 14, + CmdAceAntiCheaterCsReq = 100, + CmdPlayerLoginCsReq = 18, + CmdGetSecretKeyInfoCsReq = 78, + CmdPlayerLogoutScRsp = 37, + CmdDailyRefreshNotify = 16, + CmdSetGenderScRsp = 80, + CmdFeatureSwitchClosedScNotify = 3, + CmdPlayerKickOutScNotify = 19, + CmdPlayerLoginScRsp = 74, + CmdPlayerHeartBeatScRsp = 90, + CmdSetLanguageScRsp = 61, + CmdGetVideoVersionKeyCsReq = 1, + CmdGetBasicInfoCsReq = 42, + CmdAntiAddictScNotify = 40, + CmdReserveStaminaExchangeScRsp = 95, + CmdReserveStaminaExchangeCsReq = 71, + CmdSetNicknameCsReq = 48, + CmdPlayerGetTokenCsReq = 58, + CmdMonthCardRewardNotify = 20, + CmdQueryProductInfoScRsp = 75, + CmdGetSecretKeyInfoScRsp = 84, + CmdRetcodeNotify = 68, + CmdPlayerHeartBeatCsReq = 33, + CmdGetLevelRewardCsReq = 21, + CmdClientObjUploadScRsp = 93, + CmdGetLevelRewardTakenListScRsp = 11, + CmdSetAvatarPathScRsp = 35, + CmdGetLevelRewardScRsp = 77, + CmdGetVideoVersionKeyScRsp = 34, + CmdUpdatePsnSettingsInfoScRsp = 26, + CmdClientObjDownloadDataScNotify = 99, + CmdSetGameplayBirthdayCsReq = 36, + CmdSetNicknameScRsp = 73, + CmdUnlockAvatarPathCsReq = 97, + _, +}; + +pub const AuthkeySignType = enum(i32) { + AUTHKEY_SIGN_TYPE_NONE = 0, + AUTHKEY_SIGN_TYPE_DEFAULT = 1, + AUTHKEY_SIGN_TYPE_RSA = 2, + _, +}; + +pub const KickType = enum(i32) { + KICK_SQUEEZED = 0, + KICK_BLACK = 1, + KICK_CHANGE_PWD = 2, + KICK_LOGIN_WHITE_TIMEOUT = 3, + KICK_ACE_ANTI_CHEATER = 4, + KICK_BY_GM = 5, + _, +}; + +pub const GOBOIJFNFIL = enum(i32) { + CmdPlayerBoardTypeNone = 0, + CmdSetAssistAvatarScRsp = 2846, + CmdUnlockHeadIconScNotify = 2819, + CmdSetSignatureScRsp = 2889, + CmdSetDisplayAvatarScRsp = 2849, + CmdSetDisplayAvatarCsReq = 2858, + CmdSetHeadIconScRsp = 2837, + CmdSetHeadIconCsReq = 2829, + CmdSetAssistAvatarCsReq = 2857, + CmdSetIsDisplayAvatarInfoScRsp = 2841, + CmdSetIsDisplayAvatarInfoCsReq = 2828, + CmdGetPlayerBoardDataCsReq = 2818, + CmdGetPlayerBoardDataScRsp = 2874, + CmdSetSignatureCsReq = 2864, + _, +}; + +pub const JGMJKPPLBHF = enum(i32) { + CmdPlayerReturnTypeNone = 0, + CmdPlayerReturnTakeRewardCsReq = 4528, + CmdPlayerReturnTakePointRewardCsReq = 4558, + CmdPlayerReturnPointChangeScNotify = 4537, + CmdPlayerReturnTakeRewardScRsp = 4541, + CmdPlayerReturnSignCsReq = 4574, + CmdPlayerReturnInfoQueryScRsp = 4564, + CmdPlayerReturnSignScRsp = 4529, + CmdPlayerReturnInfoQueryCsReq = 4519, + CmdPlayerReturnTakePointRewardScRsp = 4549, + CmdPlayerReturnForceFinishScNotify = 4589, + CmdPlayerReturnStartScNotify = 4518, + _, +}; + +pub const LDMJPFCLMJI = enum(i32) { + PLAYER_RETURN_NONE = 0, + PLAYER_RETURN_PROCESSING = 1, + PLAYER_RETURN_FINISH = 2, + _, +}; + +pub const CmdPlotType = enum(i32) { + CmdPlotTypeNone = 0, + CmdFinishPlotCsReq = 1118, + CmdFinishPlotScRsp = 1174, + _, +}; + +pub const FFENJFBKDLB = enum(i32) { + CmdPunkLordTypeNone = 0, + CmdTakeKilledPunkLordMonsterScoreScRsp = 3238, + CmdPunkLordBattleResultScNotify = 3211, + CmdTakePunkLordPointRewardCsReq = 3246, + CmdGetPunkLordMonsterDataScRsp = 3274, + CmdTakePunkLordPointRewardScRsp = 3298, + CmdGetPunkLordBattleRecordScRsp = 3202, + CmdGetKilledPunkLordMonsterDataCsReq = 3221, + CmdStartPunkLordRaidCsReq = 3229, + CmdStartPunkLordRaidScRsp = 3237, + CmdSummonPunkLordMonsterScRsp = 3241, + CmdSharePunkLordMonsterCsReq = 3258, + CmdPunkLordMonsterInfoScNotify = 3283, + CmdPunkLordRaidTimeOutScNotify = 3240, + CmdTakeKilledPunkLordMonsterScoreCsReq = 3261, + CmdGetKilledPunkLordMonsterDataScRsp = 3277, + CmdSharePunkLordMonsterScRsp = 3249, + CmdPunkLordDataChangeNotify = 3282, + CmdPunkLordMonsterKilledNotify = 3247, + CmdGetPunkLordMonsterDataCsReq = 3218, + CmdSummonPunkLordMonsterCsReq = 3228, + CmdGetPunkLordBattleRecordCsReq = 3259, + CmdGetPunkLordDataCsReq = 3222, + CmdGetPunkLordDataScRsp = 3291, + _, +}; + +pub const CIDKFBGIOFM = enum(i32) { + PUNK_LORD_OPERATION_NONE = 0, + PUNK_LORD_OPERATION_REFRESH = 1, + PUNK_LORD_OPERATION_SHARE = 2, + PUNK_LORD_OPERATION_START_RAID = 3, + PUNK_LORD_OPERATION_GET_BATTLE_RECORD = 4, + _, +}; + +pub const CmdQuestType = enum(i32) { + CmdQuestTypeNone = 0, + CmdGetQuestRecordScRsp = 941, + CmdFinishQuestCsReq = 964, + CmdGetQuestDataCsReq = 918, + CmdBatchGetQuestDataCsReq = 983, + CmdQuestRecordScNotify = 919, + CmdTakeQuestRewardCsReq = 929, + CmdGetQuestDataScRsp = 974, + CmdTakeQuestOptionalRewardCsReq = 957, + CmdGetQuestRecordCsReq = 928, + CmdTakeQuestOptionalRewardScRsp = 946, + CmdBatchGetQuestDataScRsp = 922, + CmdFinishQuestScRsp = 989, + CmdTakeQuestRewardScRsp = 937, + _, +}; + +pub const QuestStatus = enum(i32) { + QUEST_NONE = 0, + QUEST_DOING = 1, + QUEST_FINISH = 2, + QUEST_CLOSE = 3, + QUEST_DELETE = 4, + _, +}; + +pub const CmdRaidType = enum(i32) { + CmdRaidTypeNone = 0, + CmdGetRaidInfoCsReq = 2289, + CmdGetAllSaveRaidScRsp = 2262, + CmdDelSaveRaidScNotify = 2240, + CmdStartRaidScRsp = 2274, + CmdLeaveRaidCsReq = 2229, + CmdGetSaveRaidScRsp = 2222, + CmdChallengeRaidNotify = 2264, + CmdRaidInfoNotify = 2258, + CmdSetClientRaidTargetCountScRsp = 2298, + CmdGetRaidInfoScRsp = 2257, + CmdSetClientRaidTargetCountCsReq = 2246, + CmdRaidKickByServerScNotify = 2248, + CmdStartRaidCsReq = 2218, + CmdTakeChallengeRaidRewardScRsp = 2219, + CmdLeaveRaidScRsp = 2237, + CmdTakeChallengeRaidRewardCsReq = 2241, + CmdGetAllSaveRaidCsReq = 2291, + CmdGetSaveRaidCsReq = 2283, + CmdGetChallengeRaidInfoScRsp = 2228, + CmdGetChallengeRaidInfoCsReq = 2249, + _, +}; + +pub const RaidStatus = enum(i32) { + RAID_STATUS_NONE = 0, + RAID_STATUS_DOING = 1, + RAID_STATUS_FINISH = 2, + RAID_STATUS_FAILED = 3, + _, +}; + +pub const DENNPFNEMIF = enum(i32) { + RAID_TARGET_STATUS_NONE = 0, + RAID_TARGET_STATUS_DOING = 1, + RAID_TARGET_STATUS_FINISH = 2, + _, +}; + +pub const HDHIENAJBKF = enum(i32) { + RAID_KICK_REASON_NONE = 0, + RAID_KICK_REASON_ACTIVITY_SCHEDULE_FINISH = 1, + _, +}; + +pub const HLAFMOLPADF = enum(i32) { + CmdRaidCollectionTypeNone = 0, + CmdRaidCollectionDataScRsp = 6957, + CmdRaidCollectionDataCsReq = 6954, + CmdRaidCollectionDataScNotify = 6953, + _, +}; + +pub const NABEKJFLIBP = enum(i32) { + CmdRedDotTypeNone = 0, + CmdGetSingleRedDotParamGroupCsReq = 5958, + CmdGetAllRedDotDataCsReq = 5918, + CmdUpdateRedDotDataScRsp = 5937, + CmdUpdateRedDotDataCsReq = 5929, + CmdGetSingleRedDotParamGroupScRsp = 5949, + CmdGetAllRedDotDataScRsp = 5974, + _, +}; + +pub const EJOFFDHCFDA = enum(i32) { + UPDATE_REDDOT_NONE = 0, + UPDATE_REDDOT_ADD = 1, + UPDATE_REDDOT_REPLACE = 2, + _, +}; + +pub const ECAFCNIFDED = enum(i32) { + CmdReplayTypeNone = 0, + CmdGetReplayTokenScRsp = 3574, + CmdGetPlayerReplayInfoCsReq = 3529, + CmdGetReplayTokenCsReq = 3518, + CmdGetPlayerReplayInfoScRsp = 3537, + _, +}; + +pub const LMFBOIMBECE = enum(i32) { + CmdRndOptionTypeNone = 0, + CmdDailyFirstMeetPamCsReq = 3429, + CmdGetRndOptionCsReq = 3418, + CmdDailyFirstMeetPamScRsp = 3437, + CmdGetRndOptionScRsp = 3474, + _, +}; + +pub const CmdRogueType = enum(i32) { + CmdRogueTypeNone = 0, + CmdPickRogueAvatarCsReq = 1822, + CmdFinishAeonDialogueGroupScRsp = 1860, + CmdExchangeRogueRewardKeyScRsp = 1890, + CmdSyncRogueStatusScNotify = 1843, + CmdReviveRogueAvatarCsReq = 1840, + CmdSyncRogueFinishScNotify = 1883, + CmdEnableRogueTalentScRsp = 1850, + CmdGetRogueInitialScoreCsReq = 1887, + CmdSyncRogueExploreWinScNotify = 1809, + CmdEnterRogueMapRoomScRsp = 1823, + CmdEnterRogueMapRoomCsReq = 1880, + CmdStartRogueScRsp = 1837, + CmdGetRogueScoreRewardInfoCsReq = 1899, + CmdEnhanceRogueBuffCsReq = 1877, + CmdOpenRogueChestScRsp = 1868, + CmdGetRogueScoreRewardInfoScRsp = 1885, + CmdReviveRogueAvatarScRsp = 1848, + CmdSyncRogueSeasonFinishScNotify = 1856, + CmdQuitRogueCsReq = 1859, + CmdGetRogueBuffEnhanceInfoScRsp = 1821, + CmdGetRogueTalentInfoScRsp = 1866, + CmdFinishAeonDialogueGroupCsReq = 1844, + CmdOpenRogueChestCsReq = 1820, + CmdStartRogueCsReq = 1829, + CmdGetRogueInfoScRsp = 1874, + CmdGetRogueTalentInfoCsReq = 1897, + CmdSyncRogueReviveInfoScNotify = 1882, + CmdEnableRogueTalentCsReq = 1855, + CmdTakeRogueScoreRewardCsReq = 1873, + CmdSyncRogueRewardInfoScNotify = 1827, + CmdTakeRogueAeonLevelRewardCsReq = 1881, + CmdSyncRogueAeonLevelUpRewardScNotify = 1865, + CmdSyncRogueVirtualItemInfoScNotify = 1863, + CmdEnhanceRogueBuffScRsp = 1824, + CmdGetRogueInfoCsReq = 1818, + CmdQuitRogueScRsp = 1802, + CmdExchangeRogueRewardKeyCsReq = 1833, + CmdEnterRogueCsReq = 1858, + CmdSyncRogueGetItemScNotify = 1851, + CmdEnterRogueScRsp = 1849, + CmdLeaveRogueScRsp = 1841, + CmdTakeRogueScoreRewardScRsp = 1808, + CmdSyncRogueMapRoomScNotify = 1814, + CmdSyncRogueAeonScNotify = 1834, + CmdGetRogueAeonInfoCsReq = 1835, + CmdSyncRogueAreaUnlockScNotify = 1817, + CmdGetRogueBuffEnhanceInfoCsReq = 1811, + CmdSyncRoguePickAvatarInfoScNotify = 1872, + CmdGetRogueInitialScoreScRsp = 1839, + CmdLeaveRogueCsReq = 1828, + CmdTakeRogueAeonLevelRewardScRsp = 1871, + CmdPickRogueAvatarScRsp = 1891, + CmdGetRogueAeonInfoScRsp = 1869, + _, +}; + +pub const RogueStatus = enum(i32) { + ROGUE_STATUS_NONE = 0, + ROGUE_STATUS_DOING = 1, + ROGUE_STATUS_PENDING = 2, + ROGUE_STATUS_ENDLESS = 3, + ROGUE_STATUS_FINISH = 4, + _, +}; + +pub const RogueRoomStatus = enum(i32) { + ROGUE_ROOM_STATUS_NONE = 0, + ROGUE_ROOM_STATUS_LOCK = 1, + ROGUE_ROOM_STATUS_UNLOCK = 2, + ROGUE_ROOM_STATUS_PLAY = 3, + ROGUE_ROOM_STATUS_FINISH = 4, + _, +}; + +pub const CKANLCGNOIL = enum(i32) { + ROGUE_AREA_STATUS_LOCK = 0, + ROGUE_AREA_STATUS_UNLOCK = 1, + ROGUE_AREA_STATUS_FIRST_PASS = 2, + ROGUE_AREA_STATUS_CLOSE = 3, + _, +}; + +pub const CAJNPBEFLHF = enum(i32) { + ROGUE_BUFF_SOURCE_TYPE_NONE = 0, + ROGUE_BUFF_SOURCE_TYPE_SELECT = 1, + ROGUE_BUFF_SOURCE_TYPE_ENHANCE = 2, + ROGUE_BUFF_SOURCE_TYPE_MIRACLE = 3, + ROGUE_BUFF_SOURCE_TYPE_DIALOGUE = 4, + ROGUE_BUFF_SOURCE_TYPE_BONUS = 5, + ROGUE_BUFF_SOURCE_TYPE_MAZE_SKILL = 6, + ROGUE_BUFF_SOURCE_TYPE_SHOP = 7, + ROGUE_BUFF_SOURCE_TYPE_LEVEL_MECHANISM = 8, + ROGUE_BUFF_SOURCE_TYPE_ENDLESS_LEVEL_START = 9, + _, +}; + +pub const GMFILIIEIHA = enum(i32) { + ROGUE_MIRACLE_SOURCE_TYPE_NONE = 0, + ROGUE_MIRACLE_SOURCE_TYPE_SELECT = 1, + ROGUE_MIRACLE_SOURCE_TYPE_DIALOGUE = 2, + ROGUE_MIRACLE_SOURCE_TYPE_BONUS = 3, + ROGUE_MIRACLE_SOURCE_TYPE_USE = 4, + ROGUE_MIRACLE_SOURCE_TYPE_RESET = 5, + ROGUE_MIRACLE_SOURCE_TYPE_REPLACE = 6, + ROGUE_MIRACLE_SOURCE_TYPE_TRADE = 7, + ROGUE_MIRACLE_SOURCE_TYPE_GET = 8, + ROGUE_MIRACLE_SOURCE_TYPE_SHOP = 9, + ROGUE_MIRACLE_SOURCE_TYPE_MAZE_SKILL = 10, + ROGUE_MIRACLE_SOURCE_TYPE_LEVEL_MECHANISM = 11, + ROGUE_MIRACLE_SOURCE_TYPE_ENDLESS_LEVEL_START = 12, + _, +}; + +pub const IJMOGDNAAEB = enum(i32) { + ROGUE_DIALOGUE_RESULT_SUCC = 0, + ROGUE_DIALOGUE_RESULT_FAIL = 1, + _, +}; + +pub const CmdRogueCommonType = enum(i32) { + CmdRogueCommonTypeNone = 0, + CmdSyncRogueCommonVirtualItemInfoScNotify = 5645, + CmdBuyRogueShopBuffScRsp = 5689, + CmdGetRogueAdventureRoomInfoScRsp = 5683, + CmdBuyRogueShopBuffCsReq = 5664, + CmdRogueDoGambleScRsp = 5669, + CmdRogueWorkbenchSelectFuncCsReq = 5644, + CmdRogueWorkbenchHandleFuncScRsp = 5651, + CmdGetRogueHandbookDataScRsp = 5670, + CmdBuyRogueShopMiracleCsReq = 5641, + CmdSyncRogueHandbookDataUpdateScNotify = 5680, + CmdPrepareRogueAdventureRoomScRsp = 5629, + CmdTakeRogueMiracleHandbookRewardScRsp = 5687, + CmdSetRogueExhibitionScRsp = 5685, + CmdCommonRogueComponentUpdateScNotify = 5625, + CmdSyncRogueCommonActionResultScNotify = 5675, + CmdExchangeRogueBuffWithMiracleScRsp = 5648, + CmdSyncRogueCommonDialogueDataScNotify = 5684, + CmdGetRogueShopMiracleInfoScRsp = 5658, + CmdCommonRogueQueryScRsp = 5668, + CmdGetRogueExhibitionScRsp = 5665, + CmdSetRogueCollectionScRsp = 5654, + CmdExchangeRogueBuffWithMiracleCsReq = 5640, + CmdGetRogueShopBuffInfoCsReq = 5649, + CmdTakeRogueEventHandbookRewardScRsp = 5614, + CmdGetRogueExhibitionCsReq = 5631, + CmdTakeRogueEventHandbookRewardCsReq = 5639, + CmdCommonRogueQueryCsReq = 5620, + CmdGetEnhanceCommonRogueBuffInfoCsReq = 5673, + CmdHandleRogueCommonPendingActionScRsp = 5610, + CmdRogueGetGambleInfoScRsp = 5652, + CmdRogueGetGambleInfoCsReq = 5630, + CmdSyncRogueAdventureRoomInfoScNotify = 5618, + CmdUpdateRogueAdventureRoomScoreCsReq = 5612, + CmdRogueDoGambleCsReq = 5635, + CmdRogueWorkbenchGetInfoCsReq = 5601, + CmdRogueNpcDisappearScRsp = 5646, + CmdGetRogueShopBuffInfoScRsp = 5628, + CmdSyncRogueCommonPendingActionScNotify = 5653, + CmdGetRogueCommonDialogueDataScRsp = 5667, + CmdStopRogueAdventureRoomCsReq = 5677, + CmdRogueWorkbenchGetInfoScRsp = 5634, + CmdUpdateRogueAdventureRoomScoreScRsp = 5642, + CmdStopRogueAdventureRoomScRsp = 5624, + CmdSyncRogueCommonDialogueOptionFinishScNotify = 5676, + CmdSelectRogueCommonDialogueOptionScRsp = 5632, + CmdRogueWorkbenchHandleFuncCsReq = 5617, + CmdGetRogueCommonDialogueDataCsReq = 5690, + CmdSelectRogueCommonDialogueOptionCsReq = 5603, + CmdFinishRogueCommonDialogueCsReq = 5694, + CmdTakeRogueMiracleHandbookRewardCsReq = 5623, + CmdPrepareRogueAdventureRoomCsReq = 5674, + CmdGetRogueHandbookDataCsReq = 5606, + CmdGetRogueCollectionScRsp = 5671, + CmdEnhanceCommonRogueBuffCsReq = 5611, + CmdBuyRogueShopMiracleScRsp = 5619, + CmdGetEnhanceCommonRogueBuffInfoScRsp = 5608, + CmdSetRogueCollectionCsReq = 5695, + CmdGetRogueCollectionCsReq = 5681, + CmdEnhanceCommonRogueBuffScRsp = 5621, + CmdCommonRogueUpdateScNotify = 5633, + CmdSetRogueExhibitionCsReq = 5699, + CmdGetRogueAdventureRoomInfoCsReq = 5698, + CmdFinishRogueCommonDialogueScRsp = 5678, + CmdRogueNpcDisappearCsReq = 5657, + CmdRogueWorkbenchSelectFuncScRsp = 5660, + CmdHandleRogueCommonPendingActionCsReq = 5700, + CmdGetRogueShopMiracleInfoCsReq = 5637, + _, +}; + +pub const APDAHOKBJAP = enum(i32) { + ROGUE_ADVENTURE_ROOM_STATUS_NONE = 0, + ROGUE_ADVENTURE_ROOM_STATUS_PREPARE = 1, + ROGUE_ADVENTURE_ROOM_STATUS_STARTED = 2, + ROGUE_ADVENTURE_ROOM_STATUS_STOPPED = 3, + _, +}; + +pub const BMGHHGAHIIN = enum(i32) { + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_NONE = 0, + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_DICE_ROLL = 1, + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_AEON = 2, + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_BOARD_EVENT = 3, + ROGUE_COMMON_BUFF_SELECT_SOURCE_TYPE_LEVEL_MECHANISM = 4, + _, +}; + +pub const JNOCIOGHICG = enum(i32) { + ROGUE_UNLOCK_FUNCTION_TYPE_MIRACLE = 0, + ROGUE_UNLOCK_FUNCTION_TYPE_SHOW_HINT = 1, + ROGUE_UNLOCK_FUNCTION_TYPE_COSMOS_BAN_AEON = 2, + ROGUE_UNLOCK_FUNTION_TYPE_EXHIBITION = 3, + ROGUE_UNLOCK_FUNTION_TYPE_COLLECTION = 4, + _, +}; + +pub const DHFMLGDLALE = enum(i32) { + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_NONE = 0, + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_DICE_ROLL = 1, + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_AEON = 2, + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_BOARD_EVENT = 3, + ROGUE_COMMON_MIRACLE_SELECT_SOURCE_TYPE_LEVEL_MECHANISM = 4, + _, +}; + +pub const NPLOEELIFFJ = enum(i32) { + ROGUE_COMMON_BUFF_DISPLAY_TYPE_NONE = 0, + ROGUE_COMMON_BUFF_DISPLAY_TYPE_ADD = 1, + ROGUE_COMMON_BUFF_DISPLAY_TYPE_REMOVE = 2, + _, +}; + +pub const ANNAIMECHHI = enum(i32) { + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_NONE = 0, + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_ADD = 1, + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_REMOVE = 2, + ROGUE_COMMON_MIRACLE_DISPLAY_TYPE_REPAIR = 3, + _, +}; + +pub const NIIEOJMNOBE = enum(i32) { + ROGUE_COMMON_ITEM_DISPLAY_TYPE_NONE = 0, + ROGUE_COMMON_ITEM_DISPLAY_TYPE_ADD = 1, + ROGUE_COMMON_ITEM_DISPLAY_TYPE_REMOVE = 2, + _, +}; + +pub const OEDKCPFBCAP = enum(i32) { + ROGUE_COMMON_ACTION_RESULT_DISPLAY_TYPE_NONE = 0, + ROGUE_COMMON_ACTION_RESULT_DISPLAY_TYPE_SINGLE = 1, + ROGUE_COMMON_ACTION_RESULT_DISPLAY_TYPE_MULTI = 2, + _, +}; + +pub const KHKFCCLABMD = enum(i32) { + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_NONE = 0, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_SELECT = 1, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_ENHANCE = 2, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_MIRACLE = 3, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_DIALOGUE = 4, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_BONUS = 5, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_SHOP = 6, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_DICE = 7, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_AEON = 8, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_BOARD_EVENT = 9, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_MAZE_SKILL = 10, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_LEVEL_MECHANISM = 11, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_BUFF = 12, + ROGUE_COMMON_ACTION_RESULT_SOURCE_TYPE_REFORGE = 13, + _, +}; + +pub const DHGHLLIDAKE = enum(i32) { + ROGUE_TALENT_STATUS_LOCK = 0, + ROGUE_TALENT_STATUS_UNLOCK = 1, + ROGUE_TALENT_STATUS_ENABLE = 2, + _, +}; + +pub const IPNEPEPBNKJ = enum(i32) { + ROGUE_COLLECTION_OPERATE_NONE = 0, + ROGUE_COLLECTION_OPERATE_SET = 1, + ROGUE_COLLECTION_OPERATE_UNSET = 2, + _, +}; + +pub const GJHNLJFKIGE = enum(i32) { + ROGUE_BOOTH_NONE = 0, + ROGUE_BOOTH_EMPTY = 1, + ROGUE_BOOTH_DISPLAY = 2, + _, +}; + +pub const CLJMGCEBLCI = enum(i32) { + ROGUE_COLLECTION_NONE = 0, + ROGUE_COLLECTION_UNLOCKED = 1, + ROGUE_COLLECTION_DISPLAY = 2, + _, +}; + +pub const JBBOKAOGBDI = enum(i32) { + ROGUE_EXHIBITION_NONE = 0, + ROGUE_EXHIBITION_UNLOCKED = 1, + ROGUE_EXHIBITION_DISPLAY = 2, + _, +}; + +pub const PDKLPPPKJJH = enum(i32) { + CmdRogueEndlessNone = 0, + CmdTakeRogueEndlessActivityPointRewardCsReq = 6008, + CmdTakeRogueEndlessActivityAllBonusRewardCsReq = 6004, + CmdGetRogueEndlessActivityDataCsReq = 6002, + CmdEnterRogueEndlessActivityStageScRsp = 6010, + CmdRogueEndlessActivityBattleEndScNotify = 6006, + CmdTakeRogueEndlessActivityAllBonusRewardScRsp = 6009, + CmdEnterRogueEndlessActivityStageCsReq = 6007, + CmdGetRogueEndlessActivityDataScRsp = 6005, + CmdTakeRogueEndlessActivityPointRewardScRsp = 6003, + _, +}; + +pub const BMCPDOJNNLK = enum(i32) { + CmdRogueModifierTypeNone = 0, + CmdRogueModifierAddNotify = 5329, + CmdRogueModifierDelNotify = 5319, + CmdRogueModifierSelectCellCsReq = 5337, + CmdRogueModifierUpdateNotify = 5341, + CmdRogueModifierStageStartNotify = 5364, + CmdRogueModifierSelectCellScRsp = 5358, + _, +}; + +pub const ILKJJKFPFHC = enum(i32) { + ROGUE_MODIFIER_SOURCE_NONE = 0, + ROGUE_MODIFIER_SOURCE_DICE_ROLL = 1, + ROGUE_MODIFIER_SOURCE_AEON = 2, + ROGUE_MODIFIER_SOURCE_BOARD_EVENT = 3, + ROGUE_MODIFIER_SOURCE_DIALOG_EVENT = 4, + ROGUE_MODIFIER_SOURCE_MIRACLE = 5, + ROGUE_MODIFIER_SOURCE_CELL_MARK = 6, + ROGUE_MODIFIER_SOURCE_AEON_TALENT = 7, + ROGUE_MODIFIER_SOURCE_BOSS_DECAY = 8, + ROGUE_MODIFIER_SOURCE_DICE_BRANCH = 9, + _, +}; + +pub const NGOLGIGLBJG = enum(i32) { + ROGUE_MODIFIER_CONTENT_DEFINITE = 0, + ROGUE_MODIFIER_CONTENT_RANDOM = 1, + _, +}; + +pub const EEPKFEELAGI = enum(i32) { + CmdRogueTournTypeNone = 0, + CmdRogueTournResetPermanentTalentScRsp = 6087, + CmdRogueTournGetMiscRealTimeDataScRsp = 6042, + CmdRogueTournDifficultyCompNotify = 6100, + CmdRogueTournEnablePermanentTalentScRsp = 6012, + CmdRogueTournLeaveRogueCocoonSceneScRsp = 6022, + CmdRogueTournGetCurRogueCocoonInfoScRsp = 6061, + CmdRogueTournTakeExpRewardScRsp = 6081, + CmdRogueTournGetCurRogueCocoonInfoCsReq = 6090, + CmdRogueTournGetAllArchiveScRsp = 6034, + CmdRogueTournReEnterRogueCocoonStageScRsp = 6074, + CmdRogueTournGetArchiveRepositoryCsReq = 6043, + CmdRogueTournStartCsReq = 6031, + CmdRogueTournGetAllArchiveCsReq = 6058, + CmdRogueTournEnterScRsp = 6028, + CmdRogueTournReviveCostUpdateScNotify = 6011, + CmdRogueTournLeaveCsReq = 6068, + CmdRogueTournResetPermanentTalentCsReq = 6066, + CmdRogueTournLeaveScRsp = 6098, + CmdRogueTournWeekChallengeUpdateScNotify = 6078, + CmdRogueTournHandBookNotify = 6020, + CmdRogueTournQueryScRsp = 6018, + CmdRogueTournTakeExpRewardCsReq = 6016, + CmdRogueTournReviveAvatarScRsp = 6071, + CmdRogueTournBattleFailSettleInfoScNotify = 6027, + CmdRogueTournEnablePermanentTalentCsReq = 6057, + CmdRogueTournClearArchiveNameScNotify = 6023, + CmdRogueTournEnterLayerCsReq = 6072, + CmdRogueTournConfirmSettleCsReq = 6091, + CmdRogueTournGetSettleInfoCsReq = 6044, + CmdRogueTournEnterRogueCocoonSceneScRsp = 6035, + CmdRogueTournReEnterRogueCocoonStageCsReq = 6026, + CmdRogueTournEnterRoomCsReq = 6033, + CmdRogueTournStartScRsp = 6093, + CmdRogueTournGetPermanentTalentInfoCsReq = 6088, + CmdRogueTournGetArchiveRepositoryScRsp = 6052, + CmdRogueTournGetSettleInfoScRsp = 6013, + CmdRogueTournConfirmSettleScRsp = 6094, + CmdRogueTournQueryCsReq = 6059, + CmdRogueTournReviveAvatarCsReq = 6083, + CmdRogueTournAreaUpdateScNotify = 6021, + CmdRogueTournExpNotify = 6030, + CmdRogueTournLeaveRogueCocoonSceneCsReq = 6050, + CmdRogueTournGetMiscRealTimeDataCsReq = 6084, + CmdRogueTournGetPermanentTalentInfoScRsp = 6092, + CmdRogueTournDeleteArchiveCsReq = 6099, + CmdRogueTournLevelInfoUpdateScNotify = 6055, + CmdRogueTournEnterCsReq = 6047, + CmdRogueTournEnterLayerScRsp = 6038, + CmdRogueTournEnterRogueCocoonSceneCsReq = 6024, + CmdRogueTournEnterRoomScRsp = 6029, + CmdRogueTournRenameArchiveScRsp = 6056, + CmdRogueTournSettleScRsp = 6069, + CmdRogueTournSettleCsReq = 6039, + CmdRogueTournRenameArchiveCsReq = 6048, + CmdRogueTournDeleteArchiveScRsp = 6063, + _, +}; + +pub const GIOJDCJKCEL = enum(i32) { + ROGUE_TOURN_LEVEL_STATUS_NONE = 0, + ROGUE_TOURN_LEVEL_STATUS_PROCESSING = 1, + ROGUE_TOURN_LEVEL_STATUS_FINISHED = 2, + ROGUE_TOURN_LEVEL_STATUS_SETTLED = 3, + _, +}; + +pub const DMMGENFFCHJ = enum(i32) { + ROGUE_TOURN_LAYER_STATUS_NONE = 0, + ROGUE_TOURN_LAYER_STATUS_PROCESSING = 1, + ROGUE_TOURN_LAYER_STATUS_FINISH = 2, + _, +}; + +pub const GJAJOJLOHEJ = enum(i32) { + ROGUE_TOURN_ROOM_STATUS_NONE = 0, + ROGUE_TOURN_ROOM_STATUS_INITED = 1, + ROGUE_TOURN_ROOM_STATUS_PROCESSING = 2, + ROGUE_TOURN_ROOM_STATUS_FINISH = 3, + _, +}; + +pub const LPKALADMPND = enum(i32) { + ROGUE_TOURN_SETTLE_REASON_NONE = 0, + ROGUE_TOURN_SETTLE_REASON_WIN = 1, + ROGUE_TOURN_SETTLE_REASON_FAIL = 2, + ROGUE_TOURN_SETTLE_REASON_INTERRUPT = 3, + _, +}; + +pub const LOEOAHCPNEN = enum(i32) { + ROGUE_TOURN_HANDBOOK_NONE = 0, + ROGUE_TOURN_HANDBOOK_SIMPLE_MIRACLE = 1, + ROGUE_TOURN_HANDBOOK_HEX_MIRACLE = 2, + ROGUE_TOURN_HANDBOOK_BUFF = 3, + ROGUE_TOURN_HANDBOOK_EVENT = 4, + ROGUE_TOURN_HANDBOOK_FORMULA = 5, + _, +}; + +pub const JBGAEHMJOFB = enum(i32) { + CmdRollShopTypeNone = 0, + CmdDoGachaInRollShopScRsp = 6905, + CmdGetRollShopInfoCsReq = 6914, + CmdTakeRollShopRewardCsReq = 6903, + CmdDoGachaInRollShopCsReq = 6913, + CmdGetRollShopInfoScRsp = 6917, + CmdTakeRollShopRewardScRsp = 6904, + _, +}; + +pub const CmdSceneType = enum(i32) { + CmdSceneTypeNone = 0, + CmdSceneEntityMoveCsReq = 1418, + CmdSceneCastSkillScRsp = 1449, + CmdEntityBindPropCsReq = 1470, + CmdEnteredSceneChangeScNotify = 1460, + CmdReturnLastTownScRsp = 1408, + CmdEnterSceneCsReq = 1425, + CmdSetClientPausedScRsp = 1487, + CmdGameplayCounterCountDownScRsp = 1485, + CmdStartTimedFarmElementScRsp = 1443, + CmdGameplayCounterRecoverScRsp = 1486, + CmdRecoverAllLineupCsReq = 1402, + CmdSpringRecoverCsReq = 1488, + CmdGroupStateChangeCsReq = 1430, + CmdDeleteSummonUnitCsReq = 1450, + CmdSceneEnterStageCsReq = 1411, + CmdSceneCastSkillCsReq = 1458, + CmdScenePlaneEventScNotify = 1417, + CmdSetGroupCustomSaveDataScRsp = 1467, + CmdEnterSectionCsReq = 1492, + CmdSpringRefreshScRsp = 1440, + CmdInteractPropScRsp = 1437, + CmdSyncEntityBuffChangeListScNotify = 1446, + CmdUpdateMechanismBarScNotify = 1433, + CmdSetGroupCustomSaveDataCsReq = 1490, + CmdSpringRecoverSingleAvatarScRsp = 1468, + CmdGetSceneMapInfoScRsp = 1481, + CmdInteractPropCsReq = 1429, + CmdSetCurInteractEntityScRsp = 1459, + CmdStartTimedCocoonStageScRsp = 1496, + CmdSceneEntityTeleportCsReq = 1484, + CmdReEnterLastElementStageScRsp = 1478, + CmdGetSpringRecoverDataScRsp = 1445, + CmdRecoverAllLineupScRsp = 1413, + CmdEnterSceneByServerScNotify = 1434, + CmdReEnterLastElementStageCsReq = 1494, + CmdGetUnlockTeleportScRsp = 1454, + CmdGroupStateChangeScNotify = 1435, + CmdRefreshTriggerByClientScRsp = 1466, + CmdStartCocoonStageScRsp = 1406, + CmdGetCurSceneInfoCsReq = 1428, + CmdGetCurSceneInfoScRsp = 1441, + CmdSceneReviveAfterRebattleCsReq = 1477, + CmdReturnLastTownCsReq = 1473, + CmdSetCurInteractEntityCsReq = 1482, + CmdDeactivateFarmElementCsReq = 1414, + CmdEnterSceneScRsp = 1401, + CmdSetSpringRecoverConfigScRsp = 1436, + CmdSceneGroupRefreshScNotify = 1405, + CmdSceneUpdatePositionVersionNotify = 1457, + CmdLastSpringRefreshTimeNotify = 1448, + CmdStartTimedFarmElementCsReq = 1463, + CmdSetClientPausedCsReq = 1423, + CmdHealPoolInfoNotify = 1410, + CmdUnlockedAreaMapScNotify = 1479, + CmdSpringRecoverScRsp = 1500, + CmdSavePointsInfoNotify = 1409, + CmdDeactivateFarmElementScRsp = 1475, + CmdSceneReviveAfterRebattleScRsp = 1424, + CmdRefreshTriggerByClientCsReq = 1497, + CmdGroupStateChangeScRsp = 1452, + CmdUpdateFloorSavedValueNotify = 1465, + CmdEnterSectionScRsp = 1447, + CmdGetEnteredSceneScRsp = 1444, + CmdRefreshTriggerByClientScNotify = 1455, + CmdGetSpringRecoverDataCsReq = 1442, + CmdActivateFarmElementCsReq = 1453, + CmdGameplayCounterCountDownCsReq = 1499, + CmdActivateFarmElementScRsp = 1412, + CmdGetSceneMapInfoCsReq = 1451, + CmdSceneCastSkillCostMpCsReq = 1498, + CmdSetSpringRecoverConfigCsReq = 1416, + CmdSyncServerSceneChangeNotify = 1471, + CmdSceneCastSkillMpUpdateScNotify = 1422, + CmdSceneCastSkillCostMpScRsp = 1483, + CmdStartCocoonStageCsReq = 1456, + CmdGetUnlockTeleportCsReq = 1495, + CmdSceneEntityMoveScRsp = 1474, + CmdGameplayCounterUpdateScNotify = 1493, + CmdSceneEnterStageScRsp = 1421, + CmdSpringRecoverSingleAvatarCsReq = 1420, + CmdSpringRefreshCsReq = 1462, + CmdUnlockTeleportNotify = 1427, + CmdGameplayCounterRecoverCsReq = 1426, + CmdEntityBindPropScRsp = 1480, + CmdDeleteSummonUnitScRsp = 1404, + CmdSceneEntityMoveScNotify = 1489, + CmdSceneEntityTeleportScRsp = 1476, + CmdStartTimedCocoonStageCsReq = 1415, + CmdGetEnteredSceneCsReq = 1469, + _, +}; + +pub const SceneCastSkillType = enum(i32) { + SCENE_CAST_SKILL_NONE = 0, + SCENE_CAST_SKILL_PROJECTILE_HIT = 1, + SCENE_CAST_SKILL_PROJECTILE_LIFETIME_FINISH = 2, + _, +}; + +pub const MonsterBattleType = enum(i32) { + MONSTER_BATTLE_TYPE_NONE = 0, + MONSTER_BATTLE_TYPE_TRIGGER_BATTLE = 1, + MONSTER_BATTLE_TYPE_DIRECT_DIE_SIMULATE_BATTLE = 2, + MONSTER_BATTLE_TYPE_DIRECT_DIE_SKIP_BATTLE = 3, + MONSTER_BATTLE_TYPE_NO_BATTLE = 4, + _, +}; + +pub const SceneEntityBuffChangeType = enum(i32) { + SCENE_ENTITY_BUFF_CHANGE_TYPE_DEFAULT = 0, + SCENE_ENTITY_BUFF_CHANGE_TYPE_ADD_MAZEBUFF = 1, + SCENE_ENTITY_BUFF_CHANGE_TYPE_ADD_ADV_MODIFIER = 2, + _, +}; + +pub const EnterSceneReason = enum(i32) { + ENTER_SCENE_REASON_NONE = 0, + ENTER_SCENE_REASON_CHALLENGE_TIMEOUT = 1, + ENTER_SCENE_REASON_ROGUE_TIMEOUT = 2, + ENTER_SCENE_REASON_CHANGE_STORYLINE = 3, + _, +}; + +pub const MapInfoChestType = enum(i32) { + MAP_INFO_CHEST_TYPE_NONE = 0, + MAP_INFO_CHEST_TYPE_NORMAL = 101, + MAP_INFO_CHEST_TYPE_CHALLENGE = 102, + MAP_INFO_CHEST_TYPE_PUZZLE = 104, + _, +}; + +pub const GameplayCounterUpdateReason = enum(i32) { + GAMEPLAY_COUNTER_UPDATE_REASON_NONE = 0, + GAMEPLAY_COUNTER_UPDATE_REASON_ACTIVATE = 1, + GAMEPLAY_COUNTER_UPDATE_REASON_DEACTIVATE = 2, + GAMEPLAY_COUNTER_UPDATE_REASON_CHANGE = 3, + _, +}; + +pub const SceneGroupRefreshType = enum(i32) { + SCENE_GROUP_REFRESH_TYPE_NONE = 0, + SCENE_GROUP_REFRESH_TYPE_LOADED = 1, + SCENE_GROUP_REFRESH_TYPE_UNLOAD = 2, + _, +}; + +pub const JDIOMKNOKMP = enum(i32) { + CmdServerPrefsTypeNone = 0, + CmdGetAllServerPrefsDataScRsp = 6174, + CmdUpdateServerPrefsDataScRsp = 6149, + CmdGetAllServerPrefsDataCsReq = 6118, + CmdGetServerPrefsDataScRsp = 6137, + CmdUpdateServerPrefsDataCsReq = 6158, + CmdGetServerPrefsDataCsReq = 6129, + _, +}; + +pub const CmdShopType = enum(i32) { + CmdShopTypeNone = 0, + CmdTakeCityShopRewardCsReq = 1558, + CmdBuyGoodsCsReq = 1529, + CmdGetShopListCsReq = 1518, + CmdCityShopInfoScNotify = 1528, + CmdTakeCityShopRewardScRsp = 1549, + CmdBuyGoodsScRsp = 1537, + CmdGetShopListScRsp = 1574, + _, +}; + +pub const OLOLICCOLJF = enum(i32) { + CmdSpaceZooTypeNone = 0, + CmdSpaceZooMutateScRsp = 6749, + CmdSpaceZooOpCatteryScRsp = 6741, + CmdSpaceZooMutateCsReq = 6758, + CmdSpaceZooBornScRsp = 6737, + CmdSpaceZooTakeScRsp = 6783, + CmdSpaceZooExchangeItemScRsp = 6746, + CmdSpaceZooExchangeItemCsReq = 6757, + CmdSpaceZooTakeCsReq = 6798, + CmdSpaceZooDataScRsp = 6774, + CmdSpaceZooOpCatteryCsReq = 6728, + CmdSpaceZooDeleteCatScRsp = 6764, + CmdSpaceZooCatUpdateNotify = 6789, + CmdSpaceZooDeleteCatCsReq = 6719, + CmdSpaceZooDataCsReq = 6718, + CmdSpaceZooBornCsReq = 6729, + _, +}; + +pub const LFBDCJAOKNE = enum(i32) { + CmdStarFightTypeNone = 0, + CmdGetStarFightDataCsReq = 7162, + CmdStarFightDataChangeNotify = 7166, + CmdStartStarFightLevelScRsp = 7170, + CmdGetStarFightDataScRsp = 7165, + CmdStartStarFightLevelCsReq = 7167, + _, +}; + +pub const PAEOAOHIGPH = enum(i32) { + CmdStoryLineTypeNone = 0, + CmdStoryLineTrialAvatarChangeScNotify = 6228, + CmdChangeStoryLineFinishScNotify = 6249, + CmdStoryLineInfoScNotify = 6229, + CmdGetStoryLineInfoScRsp = 6274, + CmdGetStoryLineInfoCsReq = 6218, + _, +}; + +pub const EJJDPOJOLMG = enum(i32) { + ChangeStoryLineAction_None = 0, + ChangeStoryLineAction_FinishAction = 1, + ChangeStoryLineAction_Client = 2, + ChangeStoryLineAction_CustomOP = 3, + _, +}; + +pub const DGEEOPEFKAO = enum(i32) { + CmdStrongChallengeActivityTypeNone = 0, + CmdGetStrongChallengeActivityDataScRsp = 6674, + CmdGetStrongChallengeActivityDataCsReq = 6618, + CmdEnterStrongChallengeActivityStageCsReq = 6629, + CmdEnterStrongChallengeActivityStageScRsp = 6637, + CmdStrongChallengeActivityBattleEndScNotify = 6658, + _, +}; + +pub const LGAFGOIKLJL = enum(i32) { + CmdSummonActivityTypeNone = 0, + CmdSummonActivityBattleEndScNotify = 7566, + CmdEnterSummonActivityStageScRsp = 7570, + CmdEnterSummonActivityStageCsReq = 7567, + CmdGetSummonActivityDataCsReq = 7562, + CmdGetSummonActivityDataScRsp = 7565, + _, +}; + +pub const GOJPOFEIHHI = enum(i32) { + CmdSwordTrainingTypeNone = 0, + CmdSwordTrainingRestoreGameCsReq = 7476, + CmdGetSwordTrainingDataScRsp = 7456, + CmdSwordTrainingGiveUpGameCsReq = 7467, + CmdSwordTrainingLearnSkillScRsp = 7481, + CmdSwordTrainingSetSkillTraceScRsp = 7472, + CmdSwordTrainingExamResultConfirmCsReq = 7488, + CmdSwordTrainingDialogueSelectOptionScRsp = 7459, + CmdSwordTrainingExamResultConfirmScRsp = 7480, + CmdSwordTrainingFinishEndingHintScRsp = 7492, + CmdSwordTrainingTakeEndingRewardCsReq = 7497, + CmdSwordTrainingResumeGameCsReq = 7452, + CmdSwordTrainingStoryBattleScRsp = 7475, + CmdSwordTrainingFinishEndingHintCsReq = 7493, + CmdSwordTrainingGameSettleScNotify = 7473, + CmdSwordTrainingResumeGameScRsp = 7490, + CmdEnterSwordTrainingExamScRsp = 7460, + CmdSwordTrainingSelectEndingCsReq = 7457, + CmdSwordTrainingDailyPhaseConfirmCsReq = 7470, + CmdSwordTrainingSetSkillTraceCsReq = 7482, + CmdSwordTrainingRestoreGameScRsp = 7468, + CmdSwordTrainingTurnActionScRsp = 7487, + CmdSwordTrainingStartGameCsReq = 7474, + CmdSwordTrainingUpdateRankScRsp = 7496, + CmdSwordTrainingActionTurnSettleScNotify = 7485, + CmdSwordTrainingTurnActionCsReq = 7495, + CmdSwordTrainingGetSkillInfoScRsp = 7465, + CmdSwordTrainingStoryConfirmScRsp = 7494, + CmdSwordTrainingDialogueSelectOptionCsReq = 7471, + CmdSwordTrainingSelectEndingScRsp = 7477, + CmdSwordTrainingStoryBattleCsReq = 7478, + CmdSwordTrainingUnlockSyncScNotify = 7484, + CmdSwordTrainingRefreshPartnerAbilityCsReq = 7500, + CmdSwordTrainingDailyPhaseConfirmScRsp = 7462, + CmdEnterSwordTrainingExamCsReq = 7491, + CmdSwordTrainingGiveUpGameScRsp = 7499, + CmdSwordTrainingGetSkillInfoCsReq = 7461, + CmdSwordTrainingLearnSkillCsReq = 7463, + CmdSwordTrainingGameSyncChangeScNotify = 7469, + CmdSwordTrainingUpdateRankCsReq = 7458, + CmdSwordTrainingRefreshPartnerAbilityScRsp = 7451, + CmdSwordTrainingStartGameScRsp = 7466, + CmdSwordTrainingStoryConfirmCsReq = 7498, + CmdGetSwordTrainingDataCsReq = 7479, + CmdSwordTrainingTakeEndingRewardScRsp = 7483, + _, +}; + +pub const IMPNHHHPMBA = enum(i32) { + SWORD_TRAIN_GAME_SOURCE_TYPE_NONE = 0, + SWORD_TRAIN_GAME_SOURCE_TYPE_TURN_SETTLE = 1, + SWORD_TRAIN_GAME_SOURCE_TYPE_STATUS_UPGRADE = 2, + SWORD_TRAIN_GAME_SOURCE_TYPE_ACTION = 3, + SWORD_TRAIN_GAME_SOURCE_TYPE_ACTION_HINT = 4, + SWORD_TRAIN_GAME_SOURCE_TYPE_STORY = 5, + SWORD_TRAIN_GAME_SOURCE_TYPE_EXAM_BONUS = 6, + SWORD_TRAIN_GAME_SOURCE_TYPE_DIALOGUE = 7, + _, +}; + +pub const JECNAADIEAE = enum(i32) { + SWORD_TRAINING_DAILY_PHASE_TYPE_NONE = 0, + SWORD_TRAINING_DAILY_PHASE_TYPE_MORNING = 1, + SWORD_TRAINING_DAILY_PHASE_TYPE_NOON = 2, + SWORD_TRAINING_DAILY_PHASE_TYPE_AFTERNOON = 3, + SWORD_TRAINING_DAILY_PHASE_TYPE_EVENING = 4, + _, +}; + +pub const FDFBKCOHBJG = enum(i32) { + SWORD_TRAINING_STATUS_TYPE_NONE = 0, + SWORD_TRAINING_STATUS_TYPE_POWER = 1, + SWORD_TRAINING_STATUS_TYPE_AGILITY = 2, + SWORD_TRAINING_STATUS_TYPE_TOUGHNESS = 3, + SWORD_TRAINING_STATUS_TYPE_PERCEPTION = 4, + _SWORD_TRAINING_STATUS_TYPE_MAX = 5, + _, +}; + +pub const JKMJAIADMLI = enum(i32) { + SWORD_TRAINING_GAME_SETTLE_NONE = 0, + SWORD_TRAINING_GAME_SETTLE_FINISH = 1, + SWORD_TRAINING_GAME_SETTLE_GIVE_UP = 2, + SWORD_TRAINING_GAME_SETTLE_BATTLE_FAILED = 3, + SWORD_TRAINING_GAME_SETTLE_FORCE = 4, + SWORD_TRAINING_GAME_SETTLE_BY_RESTORE = 5, + _, +}; + +pub const CmdPlayerSyncType = enum(i32) { + CmdPlayerSyncNone = 0, + CmdPlayerSyncScNotify = 618, + _, +}; + +pub const CmdTalkEventType = enum(i32) { + CmdTalkRewardTypeNone = 0, + CmdGetNpcTakenRewardScRsp = 2174, + CmdTakeTalkRewardScRsp = 2137, + CmdSelectInclinationTextCsReq = 2119, + CmdGetNpcTakenRewardCsReq = 2118, + CmdGetFirstTalkNpcScRsp = 2149, + CmdTakeTalkRewardCsReq = 2129, + CmdGetFirstTalkByPerformanceNpcCsReq = 2189, + CmdGetFirstTalkByPerformanceNpcScRsp = 2157, + CmdSelectInclinationTextScRsp = 2164, + CmdFinishFirstTalkNpcCsReq = 2128, + CmdFinishFirstTalkByPerformanceNpcCsReq = 2146, + CmdFinishFirstTalkByPerformanceNpcScRsp = 2198, + CmdGetFirstTalkNpcCsReq = 2158, + CmdFinishFirstTalkNpcScRsp = 2141, + _, +}; + +pub const HDAGCMGONMI = enum(i32) { + CmdTelevisionActivityTypeNone = 0, + CmdTelevisionActivityDataChangeScNotify = 6973, + CmdGetTelevisionActivityDataScRsp = 6977, + CmdEnterTelevisionActivityStageScRsp = 6963, + CmdEnterTelevisionActivityStageCsReq = 6965, + CmdGetTelevisionActivityDataCsReq = 6974, + CmdTelevisionActivityBattleEndScNotify = 6964, + _, +}; + +pub const PBIKHKPKBEL = enum(i32) { + CmdTextJoinTypeNone = 0, + CmdTextJoinQueryCsReq = 3829, + CmdTextJoinSaveScRsp = 3874, + CmdTextJoinQueryScRsp = 3837, + CmdTextJoinBatchSaveScRsp = 3849, + CmdTextJoinBatchSaveCsReq = 3858, + CmdTextJoinSaveCsReq = 3818, + _, +}; + +pub const AHNBCCHJDCN = enum(i32) { + CmdTrackPhotoActivityTypeNone = 0, + CmdGetTrackPhotoActivityDataCsReq = 7552, + CmdSettleTrackPhotoStageCsReq = 7557, + CmdGetTrackPhotoActivityDataScRsp = 7555, + CmdQuitTrackPhotoStageCsReq = 7553, + CmdSettleTrackPhotoStageScRsp = 7560, + CmdQuitTrackPhotoStageScRsp = 7554, + CmdStartTrackPhotoStageCsReq = 7556, + CmdStartTrackPhotoStageScRsp = 7558, + _, +}; + +pub const AMCAPLGBOMJ = enum(i32) { + CmdTrainVisitorTypeNone = 0, + CmdTakeTrainVisitorUntakenBehaviorRewardCsReq = 3719, + CmdTrainVisitorRewardSendNotify = 3749, + CmdGetTrainVisitorRegisterScRsp = 3741, + CmdTrainVisitorBehaviorFinishScRsp = 3774, + CmdGetTrainVisitorBehaviorScRsp = 3737, + CmdTrainVisitorBehaviorFinishCsReq = 3718, + CmdGetTrainVisitorRegisterCsReq = 3728, + CmdGetTrainVisitorBehaviorCsReq = 3729, + CmdShowNewSupplementVisitorScRsp = 3757, + CmdTakeTrainVisitorUntakenBehaviorRewardScRsp = 3764, + CmdTrainRefreshTimeNotify = 3758, + CmdShowNewSupplementVisitorCsReq = 3789, + _, +}; + +pub const GGMLOIDBIBC = enum(i32) { + TRAIN_VISITOR_REWARD_SEND_NONE = 0, + TRAIN_VISITOR_REWARD_SEND_REGISTER = 1, + TRAIN_VISITOR_REWARD_SEND_MISSION = 2, + _, +}; + +pub const EKHNDMBIDHH = enum(i32) { + TRAIN_VISITOR_STATUS_NONE = 0, + TRAIN_VISITOR_STATUS_INIT = 1, + TRAIN_VISITOR_STATUS_GET_ON = 2, + TRAIN_VISITOR_STATUS_GET_OFF = 3, + _, +}; + +pub const AILCFBABHIN = enum(i32) { + TRAIN_VISITOR_REGISTER_GET_TYPE_NONE = 0, + TRAIN_VISITOR_REGISTER_GET_TYPE_AUTO = 1, + TRAIN_VISITOR_REGISTER_GET_TYPE_MANUAL = 2, + _, +}; + +pub const LIDNOGKIGPD = enum(i32) { + CmdTravelBrochureNone = 0, + CmdTravelBrochureSetCustomValueScRsp = 6422, + CmdTravelBrochureSetPageDescStatusScRsp = 6462, + CmdTravelBrochureUpdatePasterPosCsReq = 6489, + CmdTravelBrochureSelectMessageScRsp = 6449, + CmdTravelBrochurePageResetCsReq = 6440, + CmdTravelBrochureGetDataCsReq = 6418, + CmdTravelBrochureGetPasterScNotify = 6446, + CmdTravelBrochureApplyPasterListScRsp = 6408, + CmdTravelBrochureRemovePasterScRsp = 6464, + CmdTravelBrochureGetDataScRsp = 6474, + CmdTravelBrochureUpdatePasterPosScRsp = 6457, + CmdTravelBrochureRemovePasterCsReq = 6419, + CmdTravelBrochurePageUnlockScNotify = 6429, + CmdTravelBrochureApplyPasterScRsp = 6441, + CmdTravelBrochureSetCustomValueCsReq = 6483, + CmdTravelBrochureApplyPasterCsReq = 6428, + CmdTravelBrochureSetPageDescStatusCsReq = 6491, + CmdTravelBrochurePageResetScRsp = 6448, + CmdTravelBrochureSelectMessageCsReq = 6458, + CmdTravelBrochureApplyPasterListCsReq = 6473, + _, +}; + +pub const MEMCBKNIBAJ = enum(i32) { + PAGE_NONE = 0, + PAGE_UNLOCKED = 1, + PAGE_INTERACTED = 2, + _, +}; + +pub const DAADHEDHJNH = enum(i32) { + PAGE_DESC_NONE = 0, + PAGE_DESC_SHOW_DETAIL = 1, + PAGE_DESC_COLLAPSE = 2, + _, +}; + +pub const NFEEKDMEEJK = enum(i32) { + CmdTreasureDungeonTypeNone = 0, + CmdQuitTreasureDungeonCsReq = 4411, + CmdFightTreasureDungeonMonsterCsReq = 4491, + CmdInteractTreasureDungeonGridCsReq = 4440, + CmdTreasureDungeonDataScNotify = 4418, + CmdOpenTreasureDungeonGridScRsp = 4422, + CmdGetTreasureDungeonActivityDataScRsp = 4457, + CmdUseTreasureDungeonItemScRsp = 4408, + CmdQuitTreasureDungeonScRsp = 4421, + CmdEnterTreasureDungeonCsReq = 4446, + CmdOpenTreasureDungeonGridCsReq = 4483, + CmdUseTreasureDungeonItemCsReq = 4473, + CmdGetTreasureDungeonActivityDataCsReq = 4489, + CmdFightTreasureDungeonMonsterScRsp = 4462, + CmdTreasureDungeonFinishScNotify = 4474, + CmdEnterTreasureDungeonScRsp = 4498, + CmdInteractTreasureDungeonGridScRsp = 4448, + _, +}; + +pub const HOIAHNPBDOB = enum(i32) { + TREASURE_DUNGEON_RECORD_NONE = 0, + TREASURE_DUNGEON_RECORD_ADD_HP = 1, + TREASURE_DUNGEON_RECORD_SUB_HP = 2, + TREASURE_DUNGEON_RECORD_SUB_HP_NO_EXPLORE = 3, + TREASURE_DUNGEON_RECORD_ADD_ATTACK = 5, + TREASURE_DUNGEON_RECORD_ADD_DEFENCE = 6, + TREASURE_DUNGEON_RECORD_ADD_EXPLORE = 9, + TREASURE_DUNGEON_RECORD_SUB_EXPLORE = 10, + TREASURE_DUNGEON_RECORD_ADD_EXPLORE_OVERFLOW = 11, + TREASURE_DUNGEON_RECORD_SUMMON = 15, + TREASURE_DUNGEON_RECORD_KILL = 16, + TREASURE_DUNGEON_RECORD_ADD_TRIAL_AVATAR = 20, + TREASURE_DUNGEON_RECORD_ADD_BUFF = 24, + TREASURE_DUNGEON_RECORD_UNLOCK_DOOR = 25, + TREASURE_DUNGEON_RECORD_ENEMY_ENHANCE = 27, + TREASURE_DUNGEON_RECORD_ENEMY_WEAKEN = 28, + TREASURE_DUNGEON_RECORD_ENEMY_AURA_REMOVE = 29, + TREASURE_DUNGEON_RECORD_SPECIAL_MONSTER_RUN = 30, + TREASURE_DUNGEON_RECORD_SPECIAL_MONSTER_KILL = 31, + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_TRIGGER_SUCCESS = 33, + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_TRIGGER_FAIL = 34, + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_ADD_EXPLORE = 35, + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_OPEN_GRID = 36, + TREASURE_DUNGEON_RECORD_BATTLE_BUFF_ADD_ITEM = 37, + TREASURE_DUNGEON_RECORD_AVATAR_DEAD = 40, + TREASURE_DUNGEON_RECORD_TRIAL_AVATAR_DEAD = 41, + TREASURE_DUNGEON_RECORD_ALL_AVATAR_DEAD = 42, + TREASURE_DUNGEON_RECORD_OPEN_ITEM_CHEST = 43, + _, +}; + +pub const CmdTutorialType = enum(i32) { + CmdTutorialTypeNone = 0, + CmdUnlockTutorialScRsp = 1649, + CmdUnlockTutorialGuideCsReq = 1628, + CmdFinishTutorialCsReq = 1619, + CmdGetTutorialGuideScRsp = 1637, + CmdGetTutorialCsReq = 1618, + CmdFinishTutorialGuideCsReq = 1689, + CmdGetTutorialGuideCsReq = 1629, + CmdUnlockTutorialCsReq = 1658, + CmdFinishTutorialGuideScRsp = 1657, + CmdGetTutorialScRsp = 1674, + CmdFinishTutorialScRsp = 1664, + CmdUnlockTutorialGuideScRsp = 1641, + _, +}; + +pub const TutorialStatus = enum(i32) { + TUTORIAL_NONE = 0, + TUTORIAL_UNLOCK = 1, + TUTORIAL_FINISH = 2, + _, +}; + +pub const CmdWaypointType = enum(i32) { + CmdWaypointTypeNone = 0, + CmdTakeChapterRewardScRsp = 419, + CmdSetCurWaypointCsReq = 429, + CmdSetCurWaypointScRsp = 437, + CmdGetChapterScRsp = 449, + CmdGetWaypointScRsp = 474, + CmdGetChapterCsReq = 458, + CmdWaypointShowNewCsNotify = 428, + CmdTakeChapterRewardCsReq = 441, + CmdGetWaypointCsReq = 418, + _, +}; + +pub const WaypointType = enum(i32) { + WAYPOINT_TYPE_NONE = 0, + WAYPOINT_TYPE_STAGE = 1, + WAYPOINT_TYPE_PLOT = 2, + _, +}; + +pub const WaypointUnlockType = enum(i32) { + WAYPOINT_UNLOCK_NONE = 0, + WAYPOINT_UNLOCK_PRE = 1, + WAYPOINT_UNLOCK_LEVEL = 2, + _, +}; + +pub const ALDGLMPBDEL = enum(i32) { + CmdWolfBroTypeNone = 0, + CmdGetWolfBroGameDataScRsp = 6564, + CmdStartWolfBroGameCsReq = 6518, + CmdGetWolfBroGameDataCsReq = 6519, + CmdWolfBroGameDataChangeScNotify = 6589, + CmdRestoreWolfBroGameArchiveCsReq = 6558, + CmdWolfBroGameActivateBulletScRsp = 6591, + CmdStartWolfBroGameScRsp = 6574, + CmdQuitWolfBroGameScRsp = 6541, + CmdWolfBroGameUseBulletScRsp = 6546, + CmdWolfBroGameExplodeMonsterScRsp = 6540, + CmdWolfBroGamePickupBulletCsReq = 6598, + CmdWolfBroGameExplodeMonsterCsReq = 6562, + CmdArchiveWolfBroGameScRsp = 6537, + CmdWolfBroGamePickupBulletScRsp = 6583, + CmdWolfBroGameUseBulletCsReq = 6557, + CmdQuitWolfBroGameCsReq = 6528, + CmdArchiveWolfBroGameCsReq = 6529, + CmdWolfBroGameActivateBulletCsReq = 6522, + CmdRestoreWolfBroGameArchiveScRsp = 6549, + _, +}; + +pub const DispatchType = enum(i32) { + DISPATCH_TYPE_NONE = 0, + DISPATCH_TYPE_BY_ADDR = 1, + DISPATCH_TYPE_BY_MOD = 2, + DISPATCH_TYPE_BY_RAND = 3, + DISPATCH_TYPE_BY_CHASH = 4, + DISPATCH_TYPE_BY_STICKY_SESSION = 5, + DISPATCH_TYPE_BY_OBJECT = 6, + _, +}; + +pub const PlayerBasicInfo = struct { + nickname: ManagedString = .Empty, + level: u32 = 0, + exp: u32 = 0, + stamina: u32 = 0, + mcoin: u32 = 0, + hcoin: u32 = 0, + scoin: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .nickname = fd(1, .String), + .level = fd(2, .{ .Varint = .Simple }), + .exp = fd(3, .{ .Varint = .Simple }), + .stamina = fd(4, .{ .Varint = .Simple }), + .mcoin = fd(5, .{ .Varint = .Simple }), + .hcoin = fd(6, .{ .Varint = .Simple }), + .scoin = fd(7, .{ .Varint = .Simple }), + .world_level = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpProgress = struct { + sp_cur: u32 = 0, + sp_need: u32 = 0, + + pub const _desc_table = .{ + .sp_cur = fd(1, .{ .Varint = .Simple }), + .sp_need = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BlackInfo = struct { + begin_time: i64 = 0, + end_time: i64 = 0, + limit_level: u32 = 0, + ban_type: u32 = 0, + + pub const _desc_table = .{ + .begin_time = fd(1, .{ .Varint = .Simple }), + .end_time = fd(2, .{ .Varint = .Simple }), + .limit_level = fd(3, .{ .Varint = .Simple }), + .ban_type = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNAPBOJEOLH = struct { + avatar_type: AvatarType = @enumFromInt(0), + id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(1, .{ .Varint = .Simple }), + .id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const VersionCount = struct { + version: u32 = 0, + count: u32 = 0, + + pub const _desc_table = .{ + .version = fd(1, .{ .Varint = .Simple }), + .count = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ClientDownloadData = struct { + version: u32 = 0, + time: i64 = 0, + data: ManagedString = .Empty, + + pub const _desc_table = .{ + .version = fd(1, .{ .Varint = .Simple }), + .time = fd(2, .{ .Varint = .Simple }), + .data = fd(3, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ClientObjDownloadData = struct { + NJPPMGICCOF: ManagedString = .Empty, + KNGNOBJEOLL: ?ClientDownloadData = null, + + pub const _desc_table = .{ + .NJPPMGICCOF = fd(1, .String), + .KNGNOBJEOLL = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ClientUploadData = struct { + tag: ManagedString = .Empty, + value: ManagedString = .Empty, + + pub const _desc_table = .{ + .tag = fd(1, .String), + .value = fd(2, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FeatureSwitchParam = struct { + param_list: ArrayList(u32), + + pub const _desc_table = .{ + .param_list = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FeatureSwitchInfo = struct { + type: FeatureSwitchType = @enumFromInt(0), + switch_list: ArrayList(FeatureSwitchParam), + IsAllClosed: bool = false, + + pub const _desc_table = .{ + .type = fd(1, .{ .Varint = .Simple }), + .switch_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + .IsAllClosed = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBAMNAPGHFF = struct { + EJDBCOMIEHC: ManagedString = .Empty, + KAJAOFMPALD: ManagedString = .Empty, + KFPPCBLKLKK: ManagedString = .Empty, + CFBAFJNNHCB: ManagedString = .Empty, + POIMGKAMNHI: ManagedString = .Empty, + DNKPKODMPFL: ManagedString = .Empty, + DNGJLOGFKFD: ManagedString = .Empty, + + pub const _desc_table = .{ + .EJDBCOMIEHC = fd(1, .String), + .KAJAOFMPALD = fd(2, .String), + .KFPPCBLKLKK = fd(3, .String), + .CFBAFJNNHCB = fd(4, .String), + .POIMGKAMNHI = fd(5, .String), + .DNKPKODMPFL = fd(6, .String), + .DNGJLOGFKFD = fd(7, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKMFNDFODKC = struct { + GIAAKJJAMFK: u64 = 0, + KFHJMGKBFIE: ReplayType = @enumFromInt(0), + stage_id: u32 = 0, + uid: u32 = 0, + nickname: ManagedString = .Empty, + INMOGMIPBNH: u32 = 0, + CIDMKDDJDCH: ManagedString = .Empty, + FADGPBGDLBG: u64 = 0, + MGEAKFDLCOL: u32 = 0, + HOLLKMFGADB: u32 = 0, + + pub const _desc_table = .{ + .GIAAKJJAMFK = fd(1, .{ .Varint = .Simple }), + .KFHJMGKBFIE = fd(2, .{ .Varint = .Simple }), + .stage_id = fd(3, .{ .Varint = .Simple }), + .uid = fd(4, .{ .Varint = .Simple }), + .nickname = fd(5, .String), + .INMOGMIPBNH = fd(6, .{ .Varint = .Simple }), + .CIDMKDDJDCH = fd(7, .String), + .FADGPBGDLBG = fd(8, .{ .Varint = .Simple }), + .MGEAKFDLCOL = fd(9, .{ .Varint = .Simple }), + .HOLLKMFGADB = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PunkLordBattleAvatar = struct { + avatar_id: u32 = 0, + AvatarLevel: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(1, .{ .Varint = .Simple }), + .AvatarLevel = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PunkLordBattleRecord = struct { + uid: u32 = 0, + damage_hp: u32 = 0, + is_final_hit: bool = false, + over_kill_damage_hp: u32 = 0, + battle_replay_key: ManagedString = .Empty, + avatar_list: ArrayList(PunkLordBattleAvatar), + AssistScore: u32 = 0, + DamageScore: u32 = 0, + final_hit_score: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(1, .{ .Varint = .Simple }), + .damage_hp = fd(2, .{ .Varint = .Simple }), + .is_final_hit = fd(3, .{ .Varint = .Simple }), + .over_kill_damage_hp = fd(4, .{ .Varint = .Simple }), + .battle_replay_key = fd(5, .String), + .avatar_list = fd(6, .{ .List = .{ .SubMessage = {} } }), + .AssistScore = fd(7, .{ .Varint = .Simple }), + .DamageScore = fd(8, .{ .Varint = .Simple }), + .final_hit_score = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMDAMMAFNEN = struct { + DOJCMLKIDIB: ArrayList(PunkLordBattleRecord), + + pub const _desc_table = .{ + .DOJCMLKIDIB = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFNPGIEFEIG = struct { + uid: u32 = 0, + monster_id: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(1, .{ .Varint = .Simple }), + .monster_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCNJNNJAMCG = struct { + uid: u32 = 0, + monster_id: u32 = 0, + DGFLHAEFBEP: u32 = 0, + world_level: u32 = 0, + FADGPBGDLBG: i64 = 0, + left_hp: u32 = 0, + MCPLHCCOHAH: u32 = 0, + NGFEEBAEKAM: PunkLordShareType = @enumFromInt(0), + KNACMDEJFAF: bool = false, + + pub const _desc_table = .{ + .uid = fd(1, .{ .Varint = .Simple }), + .monster_id = fd(2, .{ .Varint = .Simple }), + .DGFLHAEFBEP = fd(3, .{ .Varint = .Simple }), + .world_level = fd(4, .{ .Varint = .Simple }), + .FADGPBGDLBG = fd(5, .{ .Varint = .Simple }), + .left_hp = fd(6, .{ .Varint = .Simple }), + .MCPLHCCOHAH = fd(7, .{ .Varint = .Simple }), + .NGFEEBAEKAM = fd(8, .{ .Varint = .Simple }), + .KNACMDEJFAF = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PunkLordBattleReplay = struct { + battle_replay_key: ManagedString = .Empty, + replay_info: ?CKMFNDFODKC = null, + + pub const _desc_table = .{ + .battle_replay_key = fd(1, .String), + .replay_info = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJGNMBBPEOH = struct { + FHJDKADEFBF: u64 = 0, + MHCFIEHGNCE: u32 = 0, + IEEBLLLNIBB: u32 = 0, + + pub const _desc_table = .{ + .FHJDKADEFBF = fd(1, .{ .Varint = .Simple }), + .MHCFIEHGNCE = fd(2, .{ .Varint = .Simple }), + .IEEBLLLNIBB = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDKPHOFLFEN = struct { + PJHDAGMLBAG: ?DJGNMBBPEOH = null, + + pub const _desc_table = .{ + .PJHDAGMLBAG = fd(101, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ServerData = struct { + name: ManagedString = .Empty, + display_name: ManagedString = .Empty, + dispatch_url: ManagedString = .Empty, + env_type: ManagedString = .Empty, + title: ManagedString = .Empty, + msg: ManagedString = .Empty, + + pub const _desc_table = .{ + .name = fd(1, .String), + .display_name = fd(2, .String), + .dispatch_url = fd(3, .String), + .env_type = fd(4, .String), + .title = fd(5, .String), + .msg = fd(6, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GlobalDispatchData = struct { + retcode: u32 = 0, + msg: ManagedString = .Empty, + OOIJOCPELAE: ManagedString = .Empty, + server_list: ArrayList(ServerData), + AAGKBDNAPCP: ManagedString = .Empty, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .msg = fd(2, .String), + .OOIJOCPELAE = fd(3, .String), + .server_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .AAGKBDNAPCP = fd(5, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BGHFGPJPKLE = struct { + PPMNCKOMLEC: u32 = 0, + AJFELNGAFEG: ArrayList(u32), + LKIPBCDGDOB: ArrayList(u32), + MHHNFAGHGOL: ArrayList(u32), + FHCPDKHFIMF: ArrayList(u32), + ODDMGMGLJHD: ArrayList(u32), + OPDNOJJNJGC: bool = false, + EPKDKOBEIIM: u32 = 0, + GAJMMIHALOE: ArrayList(u32), + + pub const _desc_table = .{ + .PPMNCKOMLEC = fd(1, .{ .Varint = .Simple }), + .AJFELNGAFEG = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .LKIPBCDGDOB = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .MHHNFAGHGOL = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .FHCPDKHFIMF = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .ODDMGMGLJHD = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .OPDNOJJNJGC = fd(7, .{ .Varint = .Simple }), + .EPKDKOBEIIM = fd(8, .{ .Varint = .Simple }), + .GAJMMIHALOE = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleOp = struct { + turn_counter: u32 = 0, + state: u32 = 0, + action_entity_id: u32 = 0, + target_entity_id: u32 = 0, + op_type: u32 = 0, + skill_index: u32 = 0, + operation_counter: u32 = 0, + OHJLLCMNJNH: ManagedString = .Empty, + + pub const _desc_table = .{ + .turn_counter = fd(1, .{ .Varint = .Simple }), + .state = fd(2, .{ .Varint = .Simple }), + .action_entity_id = fd(3, .{ .Varint = .Simple }), + .target_entity_id = fd(4, .{ .Varint = .Simple }), + .op_type = fd(5, .{ .Varint = .Simple }), + .skill_index = fd(6, .{ .Varint = .Simple }), + .operation_counter = fd(7, .{ .Varint = .Simple }), + .OHJLLCMNJNH = fd(8, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleEquipment = struct { + id: u32 = 0, + level: u32 = 0, + promotion: u32 = 0, + rank: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .promotion = fd(3, .{ .Varint = .Simple }), + .rank = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleRelic = struct { + id: u32 = 0, + level: u32 = 0, + main_affix_id: u32 = 0, + sub_affix_list: ArrayList(RelicAffix), + unique_id: u32 = 0, + EDALKPMNHGB: u32 = 0, + EEOLCCFMJFF: u32 = 0, + FIAKNHKJJBD: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .main_affix_id = fd(3, .{ .Varint = .Simple }), + .sub_affix_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .unique_id = fd(5, .{ .Varint = .Simple }), + .EDALKPMNHGB = fd(6, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(7, .{ .Varint = .Simple }), + .FIAKNHKJJBD = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AvatarSkillTree = struct { + point_id: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .point_id = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RelicAffix = struct { + affix_id: u32 = 0, + cnt: u32 = 0, + step: u32 = 0, + + pub const _desc_table = .{ + .affix_id = fd(1, .{ .Varint = .Simple }), + .cnt = fd(2, .{ .Varint = .Simple }), + .step = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PFNDMOJJMEC = struct { + GAGAKHHFFLL: bool = false, + JILOAJECKOL: ArrayList(u32), + EIBCINMGAJL: u32 = 0, + DFFANAAHFKL: u32 = 0, + + pub const _desc_table = .{ + .GAGAKHHFFLL = fd(1, .{ .Varint = .Simple }), + .JILOAJECKOL = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .EIBCINMGAJL = fd(3, .{ .Varint = .Simple }), + .DFFANAAHFKL = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleAvatar = struct { + avatar_type: AvatarType = @enumFromInt(0), + id: u32 = 0, + level: u32 = 0, + rank: u32 = 0, + index: u32 = 0, + skilltree_list: ArrayList(AvatarSkillTree), + equipment_list: ArrayList(BattleEquipment), + hp: u32 = 0, + promotion: u32 = 0, + relic_list: ArrayList(BattleRelic), + world_level: u32 = 0, + IJEHMBPEHCM: u32 = 0, + CHHLDCJCHDP: ?PFNDMOJJMEC = null, + sp: ?SpProgress = null, + GEOFDFBGECI: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(1, .{ .Varint = .Simple }), + .id = fd(2, .{ .Varint = .Simple }), + .level = fd(3, .{ .Varint = .Simple }), + .rank = fd(4, .{ .Varint = .Simple }), + .index = fd(5, .{ .Varint = .Simple }), + .skilltree_list = fd(6, .{ .List = .{ .SubMessage = {} } }), + .equipment_list = fd(7, .{ .List = .{ .SubMessage = {} } }), + .hp = fd(8, .{ .Varint = .Simple }), + .promotion = fd(10, .{ .Varint = .Simple }), + .relic_list = fd(11, .{ .List = .{ .SubMessage = {} } }), + .world_level = fd(12, .{ .Varint = .Simple }), + .IJEHMBPEHCM = fd(13, .{ .Varint = .Simple }), + .CHHLDCJCHDP = fd(15, .{ .SubMessage = {} }), + .sp = fd(16, .{ .SubMessage = {} }), + .GEOFDFBGECI = fd(17, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKMNKOOCIJG = struct { + OPIPGNHDDHO: u32 = 0, + level: u32 = 0, + JMMIOGBJHPA: u32 = 0, + NPKCKJBFEGJ: u32 = 0, + + pub const _desc_table = .{ + .OPIPGNHDDHO = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .JMMIOGBJHPA = fd(3, .{ .Varint = .Simple }), + .NPKCKJBFEGJ = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKAOFAIBAMM = struct { + monster_id: u32 = 0, + cur_hp: u32 = 0, + max_hp: u32 = 0, + + pub const _desc_table = .{ + .monster_id = fd(1, .{ .Varint = .Simple }), + .cur_hp = fd(2, .{ .Varint = .Simple }), + .max_hp = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNNFMBELLON = struct { + monster_list: ArrayList(KKAOFAIBAMM), + monster_wave_param: ?OKMNKOOCIJG = null, + GJJAJHKFJHH: u32 = 0, + EGPMAHLHJDK: u32 = 0, + + pub const _desc_table = .{ + .monster_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .monster_wave_param = fd(2, .{ .SubMessage = {} }), + .GJJAJHKFJHH = fd(3, .{ .Varint = .Simple }), + .EGPMAHLHJDK = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleBuff = struct { + id: u32 = 0, + level: u32 = 0, + owner_index: u32 = 0, + wave_flag: u32 = 0, + target_index_list: ArrayList(u32), + dynamic_values: ArrayList(DynamicValuesEntry), + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .owner_index = fd(3, .{ .Varint = .Simple }), + .wave_flag = fd(4, .{ .Varint = .Simple }), + .target_index_list = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .dynamic_values = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const DynamicValuesEntry = struct { + key: ManagedString = .Empty, + value: f32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMHKHMJICCH = struct { + id: u32 = 0, + GJAPMAIEAAI: u32 = 0, + LCNDFNGMBJC: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .GJAPMAIEAAI = fd(2, .{ .Varint = .Simple }), + .LCNDFNGMBJC = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFHNBLOGEME = struct { + CDBHJHPKNJF: u32 = 0, + + pub const _desc_table = .{ + .CDBHJHPKNJF = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFKEGJCAIGP = struct { + id: u32 = 0, + GJAPMAIEAAI: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .GJAPMAIEAAI = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICKJDNMPIDA = struct { + id: u32 = 0, + progress: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .progress = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleTarget = struct { + id: u32 = 0, + progress: u32 = 0, + total_progress: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .progress = fd(2, .{ .Varint = .Simple }), + .total_progress = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOLPBMCFJDL = struct { + KNBBHOJNOFF: ArrayList(BattleTarget), + + pub const _desc_table = .{ + .KNBBHOJNOFF = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleLineup = struct { + avatar_list: ArrayList(BattleAvatar), + monster_wave_list: ArrayList(DNNFMBELLON), + buff_list: ArrayList(BattleBuff), + world_level: u32 = 0, + BLMFHOEAGIC: ArrayList(BLMFHOEAGICEntry), + FNLHAHFIGNC: ?OFHNBLOGEME = null, + OEOHGMBFAOF: ArrayList(BattleAvatar), + HEAMIJGFDMO: ?EvolveBuildBattleInfo = null, + HKOOBMMLGME: ?AELAFNKGADP = null, + + pub const _desc_table = .{ + .avatar_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .monster_wave_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .world_level = fd(7, .{ .Varint = .Simple }), + .BLMFHOEAGIC = fd(9, .{ .List = .{ .SubMessage = {} } }), + .FNLHAHFIGNC = fd(10, .{ .SubMessage = {} }), + .OEOHGMBFAOF = fd(11, .{ .List = .{ .SubMessage = {} } }), + .HEAMIJGFDMO = fd(12, .{ .SubMessage = {} }), + .HKOOBMMLGME = fd(13, .{ .SubMessage = {} }), + }; + + pub const BLMFHOEAGICEntry = struct { + key: u32 = 0, + value: ?EOLPBMCFJDL = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AELAFNKGADP = struct { + BMCLIFPPEHK: ArrayList(BMCLIFPPEHKEntry), + OOJPFKLPHFH: u32 = 0, + NNABFOLCBNN: u32 = 0, + NEFBOFLEPKO: u32 = 0, + + pub const _desc_table = .{ + .BMCLIFPPEHK = fd(1, .{ .List = .{ .SubMessage = {} } }), + .OOJPFKLPHFH = fd(2, .{ .Varint = .Simple }), + .NNABFOLCBNN = fd(3, .{ .Varint = .Simple }), + .NEFBOFLEPKO = fd(4, .{ .Varint = .Simple }), + }; + + pub const BMCLIFPPEHKEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFHFIPIOOCB = struct { + id: u32 = 0, + index: u32 = 0, + promotion: u32 = 0, + BPAHBFDHNIK: ArrayList(u32), + KBIIKJHMCLJ: BOKJGICLIPI = @enumFromInt(0), + sp: ?SpProgress = null, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .index = fd(2, .{ .Varint = .Simple }), + .promotion = fd(3, .{ .Varint = .Simple }), + .BPAHBFDHNIK = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .KBIIKJHMCLJ = fd(5, .{ .Varint = .Simple }), + .sp = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AAFAHGGCGJM = struct { + avatar_list: ArrayList(NFHFIPIOOCB), + monster_wave_list: ArrayList(DNNFMBELLON), + buff_list: ArrayList(BattleBuff), + + pub const _desc_table = .{ + .avatar_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .monster_wave_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ClientTurnSnapshot = struct { + turn_counter: u32 = 0, + random_counter: u32 = 0, + anim_event_counter: u32 = 0, + snapshot_list: ArrayList(CharacterSnapshot), + anim_event_list: ArrayList(AnimEventSnapshot), + KNBKAGLBLPO: u32 = 0, + + pub const _desc_table = .{ + .turn_counter = fd(1, .{ .Varint = .Simple }), + .random_counter = fd(2, .{ .Varint = .Simple }), + .anim_event_counter = fd(3, .{ .Varint = .Simple }), + .snapshot_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .anim_event_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .KNBKAGLBLPO = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GamecoreConfig = struct { + is_skip_verify: bool = false, + max_turn_cnt: u32 = 0, + is_auto_fight: bool = false, + csv_path: ManagedString = .Empty, + OEJNNEHLPMH: bool = false, + EFLDLIBKJMG: bool = false, + HPLFPNDNPGN: u32 = 0, + + pub const _desc_table = .{ + .is_skip_verify = fd(1, .{ .Varint = .Simple }), + .max_turn_cnt = fd(2, .{ .Varint = .Simple }), + .is_auto_fight = fd(3, .{ .Varint = .Simple }), + .csv_path = fd(4, .String), + .OEJNNEHLPMH = fd(5, .{ .Varint = .Simple }), + .EFLDLIBKJMG = fd(6, .{ .Varint = .Simple }), + .HPLFPNDNPGN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleBuffMsg = struct { + buff_id_list: ArrayList(u32), + buff_index_list: ArrayList(u32), + buff_level_list: ArrayList(u32), + buff_flag_list: ArrayList(u32), + + pub const _desc_table = .{ + .buff_id_list = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .buff_index_list = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .buff_level_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .buff_flag_list = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KALFECKFNIK = struct { + HLDOLBBEDAF: u32 = 0, + ACCDAHFLPDE: u32 = 0, + + pub const _desc_table = .{ + .HLDOLBBEDAF = fd(1, .{ .Varint = .Simple }), + .ACCDAHFLPDE = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCDMMNONGPB = struct { + JJJGINLBCAP: bool = false, + KPNOANKDNFD: ArrayList(KPNOANKDNFDEntry), + ENLKPCNONHO: ManagedString = .Empty, + + pub const _desc_table = .{ + .JJJGINLBCAP = fd(1, .{ .Varint = .Simple }), + .KPNOANKDNFD = fd(2, .{ .List = .{ .SubMessage = {} } }), + .ENLKPCNONHO = fd(3, .String), + }; + + pub const KPNOANKDNFDEntry = struct { + key: ManagedString = .Empty, + value: ?KALFECKFNIK = null, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBJPGPNHNEP = struct { + EPIFDIJHOKM: ArrayList(ClientTurnSnapshot), + BFNLCHOBOCI: ManagedString = .Empty, + IADAODPBPGO: ManagedString = .Empty, + GAKLMGJGMBJ: ArrayList(BattleReplayStringHash), + plane_id: u32 = 0, + floor_id: u32 = 0, + IMCDDFAOEPB: u32 = 0, + DMLOIPFNBDL: u32 = 0, + JJGNHHDHLEG: ?MCDMMNONGPB = null, + + pub const _desc_table = .{ + .EPIFDIJHOKM = fd(1, .{ .List = .{ .SubMessage = {} } }), + .BFNLCHOBOCI = fd(2, .String), + .IADAODPBPGO = fd(3, .String), + .GAKLMGJGMBJ = fd(4, .{ .List = .{ .SubMessage = {} } }), + .plane_id = fd(5, .{ .Varint = .Simple }), + .floor_id = fd(6, .{ .Varint = .Simple }), + .IMCDDFAOEPB = fd(7, .{ .Varint = .Simple }), + .DMLOIPFNBDL = fd(8, .{ .Varint = .Simple }), + .JJGNHHDHLEG = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleReplay = struct { + version: u32 = 0, + logic_random_seed: u32 = 0, + stage_id: u32 = 0, + lineup: ?BattleLineup = null, + op_list: ArrayList(BattleOp), + turn_snapshot_hash: ManagedString = .Empty, + maze_plane_id: u32 = 0, + extra_ability_list: ArrayList(u32), + is_ai_consider_ultra_skill: bool = false, + check_strategy: BattleCheckStrategyType = @enumFromInt(0), + battle_module_type: BattleModuleType = @enumFromInt(0), + MKMGHEFLFDC: ArrayList(FOOFENJCLPI), + HOFFCBLNFNG: u32 = 0, + IFMHGJCEJLJ: ?GamecoreConfig = null, + game_core_log_encode: ManagedString = .Empty, + KEAPPFOFEJI: u32 = 0, + BOJHPNCAKOP: u32 = 0, + AMGDKLMDGJG: ?AAFAHGGCGJM = null, + KBGCJECJHAL: ?FBJPGPNHNEP = null, + + pub const _desc_table = .{ + .version = fd(1, .{ .Varint = .Simple }), + .logic_random_seed = fd(2, .{ .Varint = .Simple }), + .stage_id = fd(3, .{ .Varint = .Simple }), + .lineup = fd(4, .{ .SubMessage = {} }), + .op_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .turn_snapshot_hash = fd(6, .String), + .maze_plane_id = fd(7, .{ .Varint = .Simple }), + .extra_ability_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .is_ai_consider_ultra_skill = fd(9, .{ .Varint = .Simple }), + .check_strategy = fd(10, .{ .Varint = .Simple }), + .battle_module_type = fd(11, .{ .Varint = .Simple }), + .MKMGHEFLFDC = fd(12, .{ .List = .{ .SubMessage = {} } }), + .HOFFCBLNFNG = fd(14, .{ .Varint = .Simple }), + .IFMHGJCEJLJ = fd(15, .{ .SubMessage = {} }), + .game_core_log_encode = fd(16, .String), + .KEAPPFOFEJI = fd(17, .{ .Varint = .Simple }), + .BOJHPNCAKOP = fd(18, .{ .Varint = .Simple }), + .AMGDKLMDGJG = fd(19, .{ .SubMessage = {} }), + .KBGCJECJHAL = fd(100, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleReplayStringHash = struct { + hash: i32 = 0, + value: ManagedString = .Empty, + + pub const _desc_table = .{ + .hash = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AvatarProperty = struct { + max_hp: f64 = 0, + attack: f64 = 0, + defence: f64 = 0, + speed: f64 = 0, + left_hp: f64 = 0, + left_sp: f64 = 0, + max_sp: f64 = 0, + + pub const _desc_table = .{ + .max_hp = fd(1, .{ .FixedInt = .I64 }), + .attack = fd(2, .{ .FixedInt = .I64 }), + .defence = fd(3, .{ .FixedInt = .I64 }), + .speed = fd(4, .{ .FixedInt = .I64 }), + .left_hp = fd(5, .{ .FixedInt = .I64 }), + .left_sp = fd(6, .{ .FixedInt = .I64 }), + .max_sp = fd(7, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EquipmentProperty = struct { + id: u32 = 0, + rank: u32 = 0, + promotion: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .rank = fd(2, .{ .Varint = .Simple }), + .promotion = fd(3, .{ .Varint = .Simple }), + .level = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AttackDamageProperty = struct { + attack_type: ManagedString = .Empty, + damage: f64 = 0, + + pub const _desc_table = .{ + .attack_type = fd(1, .String), + .damage = fd(2, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SkillUseProperty = struct { + skill_id: u32 = 0, + skill_type: ManagedString = .Empty, + skill_level: u32 = 0, + skill_use_count: u32 = 0, + LICJDKCNHLP: u32 = 0, + CHIHJKIDNHO: u32 = 0, + DEPCCGEOOPD: u32 = 0, + NMLMDNNGKHH: u32 = 0, + NBAHDFAHKAG: u32 = 0, + + pub const _desc_table = .{ + .skill_id = fd(1, .{ .Varint = .Simple }), + .skill_type = fd(2, .String), + .skill_level = fd(3, .{ .Varint = .Simple }), + .skill_use_count = fd(4, .{ .Varint = .Simple }), + .LICJDKCNHLP = fd(5, .{ .Varint = .Simple }), + .CHIHJKIDNHO = fd(6, .{ .Varint = .Simple }), + .DEPCCGEOOPD = fd(7, .{ .Varint = .Simple }), + .NMLMDNNGKHH = fd(8, .{ .Varint = .Simple }), + .NBAHDFAHKAG = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGJAJMEHHID = struct { + skill_id: u32 = 0, + KMNLHOGMIFD: f64 = 0, + KNBBHOJNOFF: ArrayList(u32), + damage: f64 = 0, + + pub const _desc_table = .{ + .skill_id = fd(1, .{ .Varint = .Simple }), + .KMNLHOGMIFD = fd(2, .{ .FixedInt = .I64 }), + .KNBBHOJNOFF = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .damage = fd(4, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DINDONJLDJI = struct { + LGEKDBJJLNI: ManagedString = .Empty, + DLLJMHNGBHL: u32 = 0, + + pub const _desc_table = .{ + .LGEKDBJJLNI = fd(1, .String), + .DLLJMHNGBHL = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGFHLDHBDFM = struct { + GPLNAGCFFKF: ManagedString = .Empty, + count: u32 = 0, + total_damage: f64 = 0, + + pub const _desc_table = .{ + .GPLNAGCFFKF = fd(1, .String), + .count = fd(2, .{ .Varint = .Simple }), + .total_damage = fd(3, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AvatarBattleInfo = struct { + avatar_type: AvatarType = @enumFromInt(0), + id: u32 = 0, + avatar_level: u32 = 0, + avatar_rank: u32 = 0, + avatar_promotion: u32 = 0, + avatar_status: ?AvatarProperty = null, + avatar_skill: ArrayList(AvatarSkillTree), + avatar_equipment: ArrayList(EquipmentProperty), + total_turns: u32 = 0, + total_damage: f64 = 0, + total_heal: f64 = 0, + total_damage_taken: f64 = 0, + total_hp_recover: f64 = 0, + total_sp_cost: f64 = 0, + stage_id: u32 = 0, + stage_type: u32 = 0, + total_break_damage: f64 = 0, + attack_type_damage: ArrayList(AttackDamageProperty), + attack_type_break_damage: ArrayList(AttackDamageProperty), + attack_type_max_damage: ArrayList(AttackDamageProperty), + skill_times: ArrayList(SkillUseProperty), + delay_cumulate: f64 = 0, + total_sp_add: u32 = 0, + sp_add_source: ArrayList(DINDONJLDJI), + total_bp_cost: u32 = 0, + die_times: u32 = 0, + revive_times: u32 = 0, + break_times: u32 = 0, + extra_turns: u32 = 0, + total_shield: f64 = 0, + total_shield_taken: f64 = 0, + total_shield_damage: f64 = 0, + initial_status: ?AvatarProperty = null, + relics: ArrayList(BattleRelic), + IJEHMBPEHCM: u32 = 0, + NEIMBIEPHJM: ArrayList(AttackDamageProperty), + DHIAIMNOAHJ: f64 = 0, + EHELGCFKAFI: f64 = 0, + AGBFFAPEGNE: f64 = 0, + GIPBPADKIEL: f64 = 0, + IAINOBNIKIK: ArrayList(LGFHLDHBDFM), + ACBLIHHMDBE: u32 = 0, + PKOCPLEPGMB: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(1, .{ .Varint = .Simple }), + .id = fd(2, .{ .Varint = .Simple }), + .avatar_level = fd(3, .{ .Varint = .Simple }), + .avatar_rank = fd(4, .{ .Varint = .Simple }), + .avatar_promotion = fd(5, .{ .Varint = .Simple }), + .avatar_status = fd(6, .{ .SubMessage = {} }), + .avatar_skill = fd(7, .{ .List = .{ .SubMessage = {} } }), + .avatar_equipment = fd(8, .{ .List = .{ .SubMessage = {} } }), + .total_turns = fd(9, .{ .Varint = .Simple }), + .total_damage = fd(10, .{ .FixedInt = .I64 }), + .total_heal = fd(11, .{ .FixedInt = .I64 }), + .total_damage_taken = fd(12, .{ .FixedInt = .I64 }), + .total_hp_recover = fd(13, .{ .FixedInt = .I64 }), + .total_sp_cost = fd(14, .{ .FixedInt = .I64 }), + .stage_id = fd(15, .{ .Varint = .Simple }), + .stage_type = fd(16, .{ .Varint = .Simple }), + .total_break_damage = fd(17, .{ .FixedInt = .I64 }), + .attack_type_damage = fd(18, .{ .List = .{ .SubMessage = {} } }), + .attack_type_break_damage = fd(19, .{ .List = .{ .SubMessage = {} } }), + .attack_type_max_damage = fd(20, .{ .List = .{ .SubMessage = {} } }), + .skill_times = fd(21, .{ .List = .{ .SubMessage = {} } }), + .delay_cumulate = fd(22, .{ .FixedInt = .I64 }), + .total_sp_add = fd(23, .{ .Varint = .Simple }), + .sp_add_source = fd(24, .{ .List = .{ .SubMessage = {} } }), + .total_bp_cost = fd(25, .{ .Varint = .Simple }), + .die_times = fd(26, .{ .Varint = .Simple }), + .revive_times = fd(27, .{ .Varint = .Simple }), + .break_times = fd(28, .{ .Varint = .Simple }), + .extra_turns = fd(29, .{ .Varint = .Simple }), + .total_shield = fd(30, .{ .FixedInt = .I64 }), + .total_shield_taken = fd(31, .{ .FixedInt = .I64 }), + .total_shield_damage = fd(32, .{ .FixedInt = .I64 }), + .initial_status = fd(33, .{ .SubMessage = {} }), + .relics = fd(34, .{ .List = .{ .SubMessage = {} } }), + .IJEHMBPEHCM = fd(35, .{ .Varint = .Simple }), + .NEIMBIEPHJM = fd(36, .{ .List = .{ .SubMessage = {} } }), + .DHIAIMNOAHJ = fd(37, .{ .FixedInt = .I64 }), + .EHELGCFKAFI = fd(38, .{ .FixedInt = .I64 }), + .AGBFFAPEGNE = fd(39, .{ .FixedInt = .I64 }), + .GIPBPADKIEL = fd(40, .{ .FixedInt = .I64 }), + .IAINOBNIKIK = fd(41, .{ .List = .{ .SubMessage = {} } }), + .ACBLIHHMDBE = fd(42, .{ .Varint = .Simple }), + .PKOCPLEPGMB = fd(43, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MonsterProperty = struct { + max_hp: f64 = 0, + attack: f64 = 0, + defence: f64 = 0, + shield: f64 = 0, + speed: f64 = 0, + left_hp: f64 = 0, + HJHNJBBPJNC: f64 = 0, + + pub const _desc_table = .{ + .max_hp = fd(1, .{ .FixedInt = .I64 }), + .attack = fd(2, .{ .FixedInt = .I64 }), + .defence = fd(3, .{ .FixedInt = .I64 }), + .shield = fd(4, .{ .FixedInt = .I64 }), + .speed = fd(5, .{ .FixedInt = .I64 }), + .left_hp = fd(6, .{ .FixedInt = .I64 }), + .HJHNJBBPJNC = fd(7, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMDKKBMJPGP = struct { + LAJMHPGEMLD: u32 = 0, + BDJOGJDADAN: f64 = 0, + JFGDNGHLPND: u32 = 0, + break_times: u32 = 0, + + pub const _desc_table = .{ + .LAJMHPGEMLD = fd(1, .{ .Varint = .Simple }), + .BDJOGJDADAN = fd(2, .{ .FixedInt = .I64 }), + .JFGDNGHLPND = fd(3, .{ .Varint = .Simple }), + .break_times = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MonsterBattleInfo = struct { + entity_id: u32 = 0, + monster_id: u32 = 0, + monster_template_id: u32 = 0, + monster_level: u32 = 0, + monster_status: ?MonsterProperty = null, + total_turns: u32 = 0, + total_damage: f64 = 0, + total_heal: f64 = 0, + total_damage_taken: f64 = 0, + total_stance_damage_taken: f64 = 0, + total_hp_recover: f64 = 0, + stage_id: u32 = 0, + battle_id: u32 = 0, + monster_type: u32 = 0, + attack_type_damage: ArrayList(AttackDamageProperty), + skill_times: ArrayList(SkillUseProperty), + stage_type: u32 = 0, + total_break_damage_taken: f64 = 0, + delay_cumulate: f64 = 0, + death_source: DeathSource = @enumFromInt(0), + wave: u32 = 0, + index_in_wave: i32 = 0, + phase: u32 = 0, + max_phase: u32 = 0, + battle_tag: BattleTag = @enumFromInt(0), + OHLDFLFFDAA: ArrayList(LGJAJMEHHID), + EAMKAKODOME: u32 = 0, + KEGOHOLLDCD: ArrayList(CMDKKBMJPGP), + DMNFJCOIPCH: u32 = 0, + FPFDDEFFPPG: u32 = 0, + APDDNOACIMG: DIKEHIIKNII = @enumFromInt(0), + + pub const _desc_table = .{ + .entity_id = fd(1, .{ .Varint = .Simple }), + .monster_id = fd(2, .{ .Varint = .Simple }), + .monster_template_id = fd(3, .{ .Varint = .Simple }), + .monster_level = fd(4, .{ .Varint = .Simple }), + .monster_status = fd(5, .{ .SubMessage = {} }), + .total_turns = fd(6, .{ .Varint = .Simple }), + .total_damage = fd(7, .{ .FixedInt = .I64 }), + .total_heal = fd(8, .{ .FixedInt = .I64 }), + .total_damage_taken = fd(9, .{ .FixedInt = .I64 }), + .total_stance_damage_taken = fd(10, .{ .FixedInt = .I64 }), + .total_hp_recover = fd(11, .{ .FixedInt = .I64 }), + .stage_id = fd(12, .{ .Varint = .Simple }), + .battle_id = fd(13, .{ .Varint = .Simple }), + .monster_type = fd(14, .{ .Varint = .Simple }), + .attack_type_damage = fd(15, .{ .List = .{ .SubMessage = {} } }), + .skill_times = fd(16, .{ .List = .{ .SubMessage = {} } }), + .stage_type = fd(17, .{ .Varint = .Simple }), + .total_break_damage_taken = fd(18, .{ .FixedInt = .I64 }), + .delay_cumulate = fd(19, .{ .FixedInt = .I64 }), + .death_source = fd(20, .{ .Varint = .Simple }), + .wave = fd(21, .{ .Varint = .Simple }), + .index_in_wave = fd(22, .{ .Varint = .Simple }), + .phase = fd(23, .{ .Varint = .Simple }), + .max_phase = fd(24, .{ .Varint = .Simple }), + .battle_tag = fd(25, .{ .Varint = .Simple }), + .OHLDFLFFDAA = fd(26, .{ .List = .{ .SubMessage = {} } }), + .EAMKAKODOME = fd(27, .{ .Varint = .Simple }), + .KEGOHOLLDCD = fd(28, .{ .List = .{ .SubMessage = {} } }), + .DMNFJCOIPCH = fd(29, .{ .Varint = .Simple }), + .FPFDDEFFPPG = fd(30, .{ .Varint = .Simple }), + .APDDNOACIMG = fd(31, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMKPMIFNFBC = struct { + sp: ?SpProgress = null, + + pub const _desc_table = .{ + .sp = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FOOFENJCLPI = struct { + DGGCAFCLPFB: u32 = 0, + status: ?PMKPMIFNFBC = null, + OHLDFLFFDAA: ArrayList(LGJAJMEHHID), + + pub const _desc_table = .{ + .DGGCAFCLPFB = fd(1, .{ .Varint = .Simple }), + .status = fd(2, .{ .SubMessage = {} }), + .OHLDFLFFDAA = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKCCNPNLLPB = struct { + OOFAJAGAAOL: u32 = 0, + FDDOLEGBPHH: u32 = 0, + + pub const _desc_table = .{ + .OOFAJAGAAOL = fd(1, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGFELGLKHJB = struct { + avatar_id: u32 = 0, + FDJLGFOIGLC: ArrayList(u32), + LGEKDBJJLNI: u32 = 0, + damage: f64 = 0, + ADDNFEHNKND: ArrayList(u32), + MMCOMAFJAFE: i32 = 0, + MNJCOOOCNPP: f64 = 0, + BLOGHLFDLKH: u32 = 0, + wave: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(1, .{ .Varint = .Simple }), + .FDJLGFOIGLC = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .LGEKDBJJLNI = fd(3, .{ .Varint = .Simple }), + .damage = fd(4, .{ .FixedInt = .I64 }), + .ADDNFEHNKND = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .MMCOMAFJAFE = fd(6, .{ .Varint = .Simple }), + .MNJCOOOCNPP = fd(7, .{ .FixedInt = .I64 }), + .BLOGHLFDLKH = fd(8, .{ .Varint = .Simple }), + .wave = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHGPDFHGFBE = struct { + avatar_id: u32 = 0, + PIEFKMAGIDN: i32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(1, .{ .Varint = .Simple }), + .PIEFKMAGIDN = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDMLINEHPPE = struct { + LAJMHPGEMLD: u32 = 0, + monster_id: u32 = 0, + ENNPNMILKOD: ArrayList(EHGPDFHGFBE), + KMNLHOGMIFD: u32 = 0, + + pub const _desc_table = .{ + .LAJMHPGEMLD = fd(1, .{ .Varint = .Simple }), + .monster_id = fd(2, .{ .Varint = .Simple }), + .ENNPNMILKOD = fd(3, .{ .List = .{ .SubMessage = {} } }), + .KMNLHOGMIFD = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IGOJKPCDFNN = struct { + EEOLCCFMJFF: JAPMFPGNPEF = @enumFromInt(0), + FEPOOKDILKO: u32 = 0, + FJOJLFMCPKP: u32 = 0, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(1, .{ .Varint = .Simple }), + .FEPOOKDILKO = fd(2, .{ .Varint = .Simple }), + .FJOJLFMCPKP = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AAOEPMKPNOK = struct { + KBJCAOHNBIA: u32 = 0, + ODOKIDFKEPK: u32 = 0, + + pub const _desc_table = .{ + .KBJCAOHNBIA = fd(1, .{ .Varint = .Simple }), + .ODOKIDFKEPK = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOGAOBCPBHK = struct { + OPKGLFMKDGO: u32 = 0, + OJNOMLGBILP: bool = false, + MECOFHJEGIP: ?AAOEPMKPNOK = null, + + pub const _desc_table = .{ + .OPKGLFMKDGO = fd(1, .{ .Varint = .Simple }), + .OJNOMLGBILP = fd(2, .{ .Varint = .Simple }), + .MECOFHJEGIP = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHJEIEBCMOL = struct { + DDNFPMCPAIE: u32 = 0, + + pub const _desc_table = .{ + .DDNFPMCPAIE = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EvolveBuildGearDamageInfo = struct { + gear_id: u32 = 0, + damage: f64 = 0, + hp_damage: f64 = 0, + + pub const _desc_table = .{ + .gear_id = fd(1, .{ .Varint = .Simple }), + .damage = fd(2, .{ .FixedInt = .I64 }), + .hp_damage = fd(3, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGBDMBJDNLK = struct { + HPCPFPKLPJJ: ArrayList(u32), + + pub const _desc_table = .{ + .HPCPFPKLPJJ = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGBKOOIMDBG = struct { + wave: u32 = 0, + FDDOLEGBPHH: u32 = 0, + FKBFHFIECNF: u32 = 0, + LOGAJLLEPGC: ArrayList(AAOEPMKPNOK), + KMNLHOGMIFD: f32 = 0, + + pub const _desc_table = .{ + .wave = fd(1, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(2, .{ .Varint = .Simple }), + .FKBFHFIECNF = fd(3, .{ .Varint = .Simple }), + .LOGAJLLEPGC = fd(4, .{ .List = .{ .SubMessage = {} } }), + .KMNLHOGMIFD = fd(5, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEDDDDANPKB = struct { + FGJEMDMHBIN: u32 = 0, + BJHPKLNLGLG: ArrayList(GGBKOOIMDBG), + + pub const _desc_table = .{ + .FGJEMDMHBIN = fd(1, .{ .Varint = .Simple }), + .BJHPKLNLGLG = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EvolveBuildBattleInfo = struct { + cur_level_id: u32 = 0, + cur_period: u32 = 0, + cur_coin: u32 = 0, + weapon_slot_list: ArrayList(MOGAOBCPBHK), + accessory_slot_list: ArrayList(MOGAOBCPBHK), + BanGearList: ArrayList(u32), + collection: ?LGBDMBJDNLK = null, + allowed_gear_list: ArrayList(u32), + cur_exp: u32 = 0, + cur_reroll: u32 = 0, + cur_treasure_miss_cnt: u32 = 0, + period_id_list: ArrayList(u32), + cur_gear_lost_cnt: u32 = 0, + cur_wave: u32 = 0, + is_unlock_gear_reroll: bool = false, + is_unlock_gear_ban: bool = false, + card_list: ArrayList(BHJEIEBCMOL), + gear_damage_list: ArrayList(EvolveBuildGearDamageInfo), + stat_params: ArrayList(u32), + is_giveup: bool = false, + cur_unused_round_cnt: u32 = 0, + StatLogInfo: ?HEDDDDANPKB = null, + period_first_random_seed: u32 = 0, + + pub const _desc_table = .{ + .cur_level_id = fd(1, .{ .Varint = .Simple }), + .cur_period = fd(2, .{ .Varint = .Simple }), + .cur_coin = fd(3, .{ .Varint = .Simple }), + .weapon_slot_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .accessory_slot_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .BanGearList = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .collection = fd(7, .{ .SubMessage = {} }), + .allowed_gear_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .cur_exp = fd(9, .{ .Varint = .Simple }), + .cur_reroll = fd(10, .{ .Varint = .Simple }), + .cur_treasure_miss_cnt = fd(11, .{ .Varint = .Simple }), + .period_id_list = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .cur_gear_lost_cnt = fd(13, .{ .Varint = .Simple }), + .cur_wave = fd(14, .{ .Varint = .Simple }), + .is_unlock_gear_reroll = fd(15, .{ .Varint = .Simple }), + .is_unlock_gear_ban = fd(16, .{ .Varint = .Simple }), + .card_list = fd(17, .{ .List = .{ .SubMessage = {} } }), + .gear_damage_list = fd(18, .{ .List = .{ .SubMessage = {} } }), + .stat_params = fd(19, .{ .PackedList = .{ .Varint = .Simple } }), + .is_giveup = fd(20, .{ .Varint = .Simple }), + .cur_unused_round_cnt = fd(21, .{ .Varint = .Simple }), + .StatLogInfo = fd(22, .{ .SubMessage = {} }), + .period_first_random_seed = fd(23, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IAAPEGFCIID = struct { + phase: ManagedString = .Empty, + FDHEMBFJLOB: f32 = 0, + JADBFHJLEKA: f32 = 0, + EEJCPJBPLFG: u32 = 0, + BPAIGHAOFFN: u32 = 0, + FKNAKDOCILL: u32 = 0, + PIBLHEJAIDK: u32 = 0, + LGGANMFIPMD: u32 = 0, + CPKDFEHBIAI: ArrayList(u32), + GPNLHKHAPCF: ArrayList(u32), + + pub const _desc_table = .{ + .phase = fd(1, .String), + .FDHEMBFJLOB = fd(2, .{ .FixedInt = .I32 }), + .JADBFHJLEKA = fd(3, .{ .FixedInt = .I32 }), + .EEJCPJBPLFG = fd(4, .{ .Varint = .Simple }), + .BPAIGHAOFFN = fd(5, .{ .Varint = .Simple }), + .FKNAKDOCILL = fd(6, .{ .Varint = .Simple }), + .PIBLHEJAIDK = fd(7, .{ .Varint = .Simple }), + .LGGANMFIPMD = fd(8, .{ .Varint = .Simple }), + .CPKDFEHBIAI = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .GPNLHKHAPCF = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHJEAHMHGFK = struct { + NKMPHCAKDFB: u32 = 0, + CIFPKLDFOHM: u32 = 0, + JNNMLJNBMDK: u32 = 0, + FLGJGNDGCKP: u32 = 0, + ABKHBHJJEOG: u32 = 0, + FIIPHJICDIL: u32 = 0, + AFHJGLGLKHD: ArrayList(u32), + PNIJOFACALI: ArrayList(IAAPEGFCIID), + + pub const _desc_table = .{ + .NKMPHCAKDFB = fd(1, .{ .Varint = .Simple }), + .CIFPKLDFOHM = fd(2, .{ .Varint = .Simple }), + .JNNMLJNBMDK = fd(3, .{ .Varint = .Simple }), + .FLGJGNDGCKP = fd(4, .{ .Varint = .Simple }), + .ABKHBHJJEOG = fd(5, .{ .Varint = .Simple }), + .FIIPHJICDIL = fd(6, .{ .Varint = .Simple }), + .AFHJGLGLKHD = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .PNIJOFACALI = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DKODPCDGOOL = struct { + wave: u32 = 0, + EPIKPLJCPMK: f64 = 0, + DPFILOAPLPO: f64 = 0, + + pub const _desc_table = .{ + .wave = fd(1, .{ .Varint = .Simple }), + .EPIKPLJCPMK = fd(2, .{ .FixedInt = .I64 }), + .DPFILOAPLPO = fd(3, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLJLLOFIBML = struct { + MBBNDDLBEPE: ManagedString = .Empty, + value: f64 = 0, + + pub const _desc_table = .{ + .MBBNDDLBEPE = fd(1, .String), + .value = fd(2, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleStatistics = struct { + total_battle_turns: u32 = 0, + total_auto_turns: u32 = 0, + avatar_id_list: ArrayList(u32), + ultra_cnt: u32 = 0, + total_delay_cumulate: f64 = 0, + cost_time: f64 = 0, + avatar_battle_list: ArrayList(AvatarBattleInfo), + monster_battle_list: ArrayList(MonsterBattleInfo), + round_cnt: u32 = 0, + cocoon_dead_wave: u32 = 0, + avatar_battle_turns: u32 = 0, + monster_battle_turns: u32 = 0, + custom_values: ArrayList(CustomValuesEntry), + challenge_score: u32 = 0, + PJOECEPBPOJ: ArrayList(FOOFENJCLPI), + JDBPNIHHCDK: BattleEndReason = @enumFromInt(0), + OIPOMFPKFIE: ArrayList(LGFELGLKHJB), + DENNDAGNJNN: ArrayList(i32), + CGOHELIDBBC: ArrayList(EDMLINEHPPE), + ENCPJPEHIDD: ArrayList(IGOJKPCDFNN), + OGEGBEKLPAB: ArrayList(CKLPMMEKCDF), + BLMFHOEAGIC: ArrayList(BLMFHOEAGICEntry), + ENKHGICLCFO: ArrayList(MFBFMKMABAO), + HEAMIJGFDMO: ?EvolveBuildBattleInfo = null, + FDBABLGMGKN: ?HHJEAHMHGFK = null, + DBHGJCODLBK: bool = false, + BJHPKLNLGLG: ArrayList(DKODPCDGOOL), + LCBLKBIMDHL: ArrayList(CLJLLOFIBML), + DAHDDICCOGD: u32 = 0, + + pub const _desc_table = .{ + .total_battle_turns = fd(1, .{ .Varint = .Simple }), + .total_auto_turns = fd(2, .{ .Varint = .Simple }), + .avatar_id_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .ultra_cnt = fd(4, .{ .Varint = .Simple }), + .total_delay_cumulate = fd(5, .{ .FixedInt = .I64 }), + .cost_time = fd(6, .{ .FixedInt = .I64 }), + .avatar_battle_list = fd(7, .{ .List = .{ .SubMessage = {} } }), + .monster_battle_list = fd(8, .{ .List = .{ .SubMessage = {} } }), + .round_cnt = fd(9, .{ .Varint = .Simple }), + .cocoon_dead_wave = fd(10, .{ .Varint = .Simple }), + .avatar_battle_turns = fd(11, .{ .Varint = .Simple }), + .monster_battle_turns = fd(12, .{ .Varint = .Simple }), + .custom_values = fd(13, .{ .List = .{ .SubMessage = {} } }), + .challenge_score = fd(14, .{ .Varint = .Simple }), + .PJOECEPBPOJ = fd(16, .{ .List = .{ .SubMessage = {} } }), + .JDBPNIHHCDK = fd(19, .{ .Varint = .Simple }), + .OIPOMFPKFIE = fd(21, .{ .List = .{ .SubMessage = {} } }), + .DENNDAGNJNN = fd(22, .{ .PackedList = .{ .Varint = .Simple } }), + .CGOHELIDBBC = fd(23, .{ .List = .{ .SubMessage = {} } }), + .ENCPJPEHIDD = fd(26, .{ .List = .{ .SubMessage = {} } }), + .OGEGBEKLPAB = fd(27, .{ .List = .{ .SubMessage = {} } }), + .BLMFHOEAGIC = fd(28, .{ .List = .{ .SubMessage = {} } }), + .ENKHGICLCFO = fd(29, .{ .List = .{ .SubMessage = {} } }), + .HEAMIJGFDMO = fd(30, .{ .SubMessage = {} }), + .FDBABLGMGKN = fd(31, .{ .SubMessage = {} }), + .DBHGJCODLBK = fd(32, .{ .Varint = .Simple }), + .BJHPKLNLGLG = fd(33, .{ .List = .{ .SubMessage = {} } }), + .LCBLKBIMDHL = fd(34, .{ .List = .{ .SubMessage = {} } }), + .DAHDDICCOGD = fd(35, .{ .Varint = .Simple }), + }; + + pub const CustomValuesEntry = struct { + key: ManagedString = .Empty, + value: f32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const BLMFHOEAGICEntry = struct { + key: u32 = 0, + value: ?EOLPBMCFJDL = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFBFMKMABAO = struct { + HLJOMLAEJFA: u32 = 0, + AJGLBHJIJMM: u32 = 0, + + pub const _desc_table = .{ + .HLJOMLAEJFA = fd(1, .{ .Varint = .Simple }), + .AJGLBHJIJMM = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKLPMMEKCDF = struct { + EEOLCCFMJFF: BOKJGICLIPI = @enumFromInt(0), + id: u32 = 0, + sp: ?SpProgress = null, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(1, .{ .Varint = .Simple }), + .id = fd(2, .{ .Varint = .Simple }), + .sp = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HeroPath = struct { + hero_path_type: u32 = 0, + level: u32 = 0, + exp: u32 = 0, + + pub const _desc_table = .{ + .hero_path_type = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .exp = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BattleResult = struct { + retcode: BattleCheckResultType = @enumFromInt(0), + end_status: BattleEndStatus = @enumFromInt(0), + stt: ?BattleStatistics = null, + game_core_log_encode: ManagedString = .Empty, + tags: ArrayList(TagsEntry), + mismatch_turn_count: u32 = 0, + JHIKGPKANNM: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .end_status = fd(2, .{ .Varint = .Simple }), + .stt = fd(3, .{ .SubMessage = {} }), + .game_core_log_encode = fd(4, .String), + .tags = fd(5, .{ .List = .{ .SubMessage = {} } }), + .mismatch_turn_count = fd(6, .{ .Varint = .Simple }), + .JHIKGPKANNM = fd(7, .{ .Varint = .Simple }), + }; + + pub const TagsEntry = struct { + key: ManagedString = .Empty, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CharacterSnapshot = struct { + runtime_id: u32 = 0, + properties: ArrayList(u64), + + pub const _desc_table = .{ + .runtime_id = fd(1, .{ .Varint = .Simple }), + .properties = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AnimEventSnapshot = struct { + event_name: ManagedString = .Empty, + count: u32 = 0, + + pub const _desc_table = .{ + .event_name = fd(1, .String), + .count = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IBIGJKBJNJH = struct { + uid: u32 = 0, + level: u32 = 0, + nickname: ManagedString = .Empty, + IHPLGEBKNAD: u32 = 0, + platform: PlatformType = @enumFromInt(0), + OPIACEKOANJ: ManagedString = .Empty, + HJKKDCOAOHG: ManagedString = .Empty, + version: u64 = 0, + + pub const _desc_table = .{ + .uid = fd(1, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .nickname = fd(3, .String), + .IHPLGEBKNAD = fd(4, .{ .Varint = .Simple }), + .platform = fd(5, .{ .Varint = .Simple }), + .OPIACEKOANJ = fd(6, .String), + .HJKKDCOAOHG = fd(7, .String), + .version = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IIMOMGBBADM = struct { + JDIODALOMDC: CGDIIHJICCK = @enumFromInt(0), + status: IGNGFHOJMIA = @enumFromInt(0), + + pub const _desc_table = .{ + .JDIODALOMDC = fd(1, .{ .Varint = .Simple }), + .status = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LIHLCOGDOEB = struct { + JIELNNCBKOD: u32 = 0, + LHJANHPLIAD: bool = false, + DAICAPPEPIP: u32 = 0, + HJKFGHOLNKH: u32 = 0, + + pub const _desc_table = .{ + .JIELNNCBKOD = fd(1, .{ .Varint = .Simple }), + .LHJANHPLIAD = fd(2, .{ .Varint = .Simple }), + .DAICAPPEPIP = fd(3, .{ .Varint = .Simple }), + .HJKFGHOLNKH = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBEBLKIKGMP = struct { + PEBAMLHLIGH: ArrayList(ManagedString), + GAMJFCBOBBE: bool = false, + NHHDNMDKNGI: ?LIHLCOGDOEB = null, + + pub const _desc_table = .{ + .PEBAMLHLIGH = fd(1, .{ .List = .String }), + .GAMJFCBOBBE = fd(2, .{ .Varint = .Simple }), + .NHHDNMDKNGI = fd(1001, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJMGIJBHCPE = struct { + basic_info: ?IBIGJKBJNJH = null, + KBNLOFPIEBL: ?IIMOMGBBADM = null, + GKGOKJJGINE: ?JBEBLKIKGMP = null, + + pub const _desc_table = .{ + .basic_info = fd(1, .{ .SubMessage = {} }), + .KBNLOFPIEBL = fd(2, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLEMBLOIKAM = struct { + LNDLAKJFLME: u32 = 0, + PMIKDCDHAOD: u32 = 0, + EFLPABAINEN: u32 = 0, + DKNCPKOHKLB: u32 = 0, + FOEHBHFCEDA: u32 = 0, + NKLLANAMKPM: u32 = 0, + LKHAJKBMKDH: u32 = 0, + DGILNFHOIKH: u32 = 0, + JNANKJMHDAA: u32 = 0, + LDPJFOCNMOC: u32 = 0, + + pub const _desc_table = .{ + .LNDLAKJFLME = fd(1, .{ .Varint = .Simple }), + .PMIKDCDHAOD = fd(2, .{ .Varint = .Simple }), + .EFLPABAINEN = fd(3, .{ .Varint = .Simple }), + .DKNCPKOHKLB = fd(4, .{ .Varint = .Simple }), + .FOEHBHFCEDA = fd(5, .{ .Varint = .Simple }), + .NKLLANAMKPM = fd(6, .{ .Varint = .Simple }), + .LKHAJKBMKDH = fd(7, .{ .Varint = .Simple }), + .DGILNFHOIKH = fd(8, .{ .Varint = .Simple }), + .JNANKJMHDAA = fd(9, .{ .Varint = .Simple }), + .LDPJFOCNMOC = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEGAEGMBJBI = struct { + PIJCPMAPJJG: u64 = 0, + DLLFEHIFKPI: HCKIOAEMKEE = @enumFromInt(0), + + pub const _desc_table = .{ + .PIJCPMAPJJG = fd(1, .{ .Varint = .Simple }), + .DLLFEHIFKPI = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGFLEOHJHML = struct { + id: u64 = 0, + GMBEAMHBGPE: HCKIOAEMKEE = @enumFromInt(0), + OIFAJBEBHKJ: ArrayList(NJMGIJBHCPE), + EEOLCCFMJFF: BNHPKNKIHAL = @enumFromInt(0), + FHJDKADEFBF: u64 = 0, + ECDOMKJJPBF: u64 = 0, + HPBNJIPNBIA: u32 = 0, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .GMBEAMHBGPE = fd(2, .{ .Varint = .Simple }), + .OIFAJBEBHKJ = fd(3, .{ .List = .{ .SubMessage = {} } }), + .EEOLCCFMJFF = fd(4, .{ .Varint = .Simple }), + .FHJDKADEFBF = fd(5, .{ .Varint = .Simple }), + .ECDOMKJJPBF = fd(6, .{ .Varint = .Simple }), + .HPBNJIPNBIA = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPEBAEADDAG = struct { + id: u32 = 0, + KGHJEOCEPKP: u32 = 0, + OHAFLLOHIPC: ArrayList(u32), + + pub const _desc_table = .{ + .id = fd(12, .{ .Varint = .Simple }), + .KGHJEOCEPKP = fd(6, .{ .Varint = .Simple }), + .OHAFLLOHIPC = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLHLMBFDIIH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHCLCHEPIDE = struct { + retcode: u32 = 0, + HAABJAIMGAF: ArrayList(MPEBAEADDAG), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .HAABJAIMGAF = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENOMBEDENFN = struct { + KPDCLJJMPBJ: u32 = 0, + id: u32 = 0, + + pub const _desc_table = .{ + .KPDCLJJMPBJ = fd(9, .{ .Varint = .Simple }), + .id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOBANAMMMEJ = struct { + KPDCLJJMPBJ: u32 = 0, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + id: u32 = 0, + + pub const _desc_table = .{ + .KPDCLJJMPBJ = fd(4, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(2, .{ .SubMessage = {} }), + .id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKDGADPFDKB = struct { + NKFPAEFJNMP: u32 = 0, + end_time: i64 = 0, + begin_time: i64 = 0, + ABEDIGLKNCF: u32 = 0, + + pub const _desc_table = .{ + .NKFPAEFJNMP = fd(6, .{ .Varint = .Simple }), + .end_time = fd(7, .{ .Varint = .Simple }), + .begin_time = fd(13, .{ .Varint = .Simple }), + .ABEDIGLKNCF = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPFELGFGGHD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BAIPKGBBNNK = struct { + retcode: u32 = 0, + CJBDCINAEAD: ArrayList(KKDGADPFDKB), + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .CJBDCINAEAD = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDOCCPACJCJ = struct { + LMAIBMPOCDD: bool = false, + stage_id: u32 = 0, + + pub const _desc_table = .{ + .LMAIBMPOCDD = fd(13, .{ .Varint = .Simple }), + .stage_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHGJOAPKNOM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALNBBDBEAPN = struct { + retcode: u32 = 0, + HIJHNJKNFIN: ArrayList(MDOCCPACJCJ), + PODJNCHJCIK: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .HIJHNJKNFIN = fd(8, .{ .List = .{ .SubMessage = {} } }), + .PODJNCHJCIK = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFHMDJGALEN = struct { + EIGENMMGGDK: ?MDOCCPACJCJ = null, + + pub const _desc_table = .{ + .EIGENMMGGDK = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKKAKNMJFPN = struct { + stage_id: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOGOFMEAFHE = struct { + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .battle_info = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HJBCDIIJKNP = struct { + stage_id: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JFMJAKGMHJM = struct { + stage_id: u32 = 0, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .stage_id = fd(7, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOKALGJLMLP = struct { + stage_id: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJNFCMFFHGL = struct { + stage_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(6, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGGJMBAMECN = struct { + stage_id: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMNPLFKJDLI = struct { + stage_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(11, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILHEKADILJO = struct { + PODJNCHJCIK: u32 = 0, + status: PCEGPGNGKHN = @enumFromInt(0), + + pub const _desc_table = .{ + .PODJNCHJCIK = fd(10, .{ .Varint = .Simple }), + .status = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNECLCJJKLB = struct { + MBEDCLKGPEA: bool = false, + ICEJKDBMMFE: bool = false, + CNKAFFMGKOK: u32 = 0, + ABEDIGLKNCF: u32 = 0, + + pub const _desc_table = .{ + .MBEDCLKGPEA = fd(8, .{ .Varint = .Simple }), + .ICEJKDBMMFE = fd(7, .{ .Varint = .Simple }), + .CNKAFFMGKOK = fd(11, .{ .Varint = .Simple }), + .ABEDIGLKNCF = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDJPJIFDIAC = struct { + end_time: i64 = 0, + CNKAFFMGKOK: u32 = 0, + begin_time: i64 = 0, + + pub const _desc_table = .{ + .end_time = fd(11, .{ .Varint = .Simple }), + .CNKAFFMGKOK = fd(14, .{ .Varint = .Simple }), + .begin_time = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKBHANHOHNH = struct { + LKANNBIALAL: ArrayList(u32), + + pub const _desc_table = .{ + .LKANNBIALAL = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBBPPADAPFA = struct { + KALCNMONMHE: ArrayList(HDJPJIFDIAC), + retcode: u32 = 0, + LNIMKMBADPM: ArrayList(DNECLCJJKLB), + + pub const _desc_table = .{ + .KALCNMONMHE = fd(5, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(13, .{ .Varint = .Simple }), + .LNIMKMBADPM = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIEENMFFKCN = struct { + CNKAFFMGKOK: u32 = 0, + + pub const _desc_table = .{ + .CNKAFFMGKOK = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNGAMHDKDMO = struct { + retcode: u32 = 0, + CNKAFFMGKOK: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .CNKAFFMGKOK = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBMMEKPCABJ = struct { + CNKAFFMGKOK: u32 = 0, + + pub const _desc_table = .{ + .CNKAFFMGKOK = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCJCKJJKCOO = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + CNKAFFMGKOK: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(15, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + .CNKAFFMGKOK = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPLKILOAPKC = struct { + EGKOJHEIOHH: u32 = 0, + + pub const _desc_table = .{ + .EGKOJHEIOHH = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCEFDPAHBAF = struct { + retcode: u32 = 0, + scene: ?SceneInfo = null, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .scene = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONEALMFLINE = struct { + begin_time: i64 = 0, + end_time: i64 = 0, + ABKILLHGKKN: u32 = 0, + + pub const _desc_table = .{ + .begin_time = fd(7, .{ .Varint = .Simple }), + .end_time = fd(12, .{ .Varint = .Simple }), + .ABKILLHGKKN = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFOKDFDIJBB = struct { + ICKCNGCGJJD: ArrayList(u32), + + pub const _desc_table = .{ + .ICKCNGCGJJD = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CCBFJMNLCCB = struct { + AKNNEGHNIKD: ArrayList(ONEALMFLINE), + retcode: u32 = 0, + + pub const _desc_table = .{ + .AKNNEGHNIKD = fd(5, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLOCPCBKOMD = struct { + KHDJHHIHFGF: u32 = 0, + + pub const _desc_table = .{ + .KHDJHHIHFGF = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKBJKFCFOMC = struct { + retcode: u32 = 0, + KHDJHHIHFGF: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .KHDJHHIHFGF = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNDMNIGNOEK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDJNGKFHBFL = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPILMFDNLKI = struct { + JDEHKOHBCOJ: u32 = 0, + skill_index: u32 = 0, + IMEFCMMHNID: u32 = 0, + HJFNCLOKAON: ArrayList(u32), + CDIHMLNGNFF: ArrayList(DGHMFJGHCGI), + + pub const _desc_table = .{ + .JDEHKOHBCOJ = fd(12, .{ .Varint = .Simple }), + .skill_index = fd(9, .{ .Varint = .Simple }), + .IMEFCMMHNID = fd(10, .{ .Varint = .Simple }), + .HJFNCLOKAON = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .CDIHMLNGNFF = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPOEBABMICF = struct { + IMEFCMMHNID: u32 = 0, + battle_info: ?GFOBLINGFBL = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMEFCMMHNID = fd(2, .{ .Varint = .Simple }), + .battle_info = fd(3, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAHEPNCHECC = struct { + LGNHDNODOLM: u32 = 0, + KJFLOGLHFPH: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(8, .{ .Varint = .Simple }), + .KJFLOGLHFPH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHNCFEOFKMN = struct { + battle_info: ?GFOBLINGFBL = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(2, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EGFIPPOGNEA = struct { + slot: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .slot = fd(11, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHFHPCFBJNE = struct { + BPAHBFDHNIK: ArrayList(EGFIPPOGNEA), + CGANFIGJJDG: u32 = 0, + promotion: u32 = 0, + sp: ?SpProgress = null, + exp: u32 = 0, + GLBBJCBKMPH: u32 = 0, + + pub const _desc_table = .{ + .BPAHBFDHNIK = fd(14, .{ .List = .{ .SubMessage = {} } }), + .CGANFIGJJDG = fd(2, .{ .Varint = .Simple }), + .promotion = fd(8, .{ .Varint = .Simple }), + .sp = fd(3, .{ .SubMessage = {} }), + .exp = fd(10, .{ .Varint = .Simple }), + .GLBBJCBKMPH = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNHMIOGHAEG = struct { + JBDBHLKFNCP: ArrayList(u32), + slot: u32 = 0, + + pub const _desc_table = .{ + .JBDBHLKFNCP = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .slot = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJMMLPCNKEP = struct { + GBIEPAPENKJ: u32 = 0, + LOAHCJEMIMM: u32 = 0, + NHFGFOCFGCG: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(13, .{ .Varint = .Simple }), + .LOAHCJEMIMM = fd(14, .{ .Varint = .Simple }), + .NHFGFOCFGCG = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBMJEDGKOHN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOAEIEFHJHI = struct { + GIDKGEBFLFL: ArrayList(AHFHPCFBJNE), + NEOEJNKCKDM: u32 = 0, + KFBJEFGKIPH: u32 = 0, + CHKKOOPNPKG: u32 = 0, + MMIJLNONOOI: u32 = 0, + retcode: u32 = 0, + MFKPNELHJBI: ArrayList(CJMMLPCNKEP), + lineup_list: ArrayList(JNHMIOGHAEG), + OHIMLBKKODO: u32 = 0, + + pub const _desc_table = .{ + .GIDKGEBFLFL = fd(10, .{ .List = .{ .SubMessage = {} } }), + .NEOEJNKCKDM = fd(3, .{ .Varint = .Simple }), + .KFBJEFGKIPH = fd(2, .{ .Varint = .Simple }), + .CHKKOOPNPKG = fd(7, .{ .Varint = .Simple }), + .MMIJLNONOOI = fd(15, .{ .Varint = .Simple }), + .retcode = fd(1, .{ .Varint = .Simple }), + .MFKPNELHJBI = fd(8, .{ .List = .{ .SubMessage = {} } }), + .lineup_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .OHIMLBKKODO = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONMDLNGGDJL = struct { + lineup: ?JNHMIOGHAEG = null, + + pub const _desc_table = .{ + .lineup = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGDNOILBLIA = struct { + retcode: u32 = 0, + lineup: ?JNHMIOGHAEG = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .lineup = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLJGEIEDNNE = struct { + GBIEPAPENKJ: u32 = 0, + slot: u32 = 0, + CGANFIGJJDG: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(2, .{ .Varint = .Simple }), + .slot = fd(6, .{ .Varint = .Simple }), + .CGANFIGJJDG = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JAIDHABILHB = struct { + retcode: u32 = 0, + PMLHOJDLOCP: ?AHFHPCFBJNE = null, + ACEEPCHBJEE: ?CJMMLPCNKEP = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .PMLHOJDLOCP = fd(13, .{ .SubMessage = {} }), + .ACEEPCHBJEE = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBJEOMAECJF = struct { + CGANFIGJJDG: u32 = 0, + slot: u32 = 0, + + pub const _desc_table = .{ + .CGANFIGJJDG = fd(2, .{ .Varint = .Simple }), + .slot = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEHBCKLAJFE = struct { + ACEEPCHBJEE: ?CJMMLPCNKEP = null, + retcode: u32 = 0, + PMLHOJDLOCP: ?AHFHPCFBJNE = null, + + pub const _desc_table = .{ + .ACEEPCHBJEE = fd(7, .{ .SubMessage = {} }), + .retcode = fd(13, .{ .Varint = .Simple }), + .PMLHOJDLOCP = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJMOGCLMLAC = struct { + CGANFIGJJDG: u32 = 0, + GBOAKHHLALN: u32 = 0, + MMIJLNONOOI: u32 = 0, + + pub const _desc_table = .{ + .CGANFIGJJDG = fd(2, .{ .Varint = .Simple }), + .GBOAKHHLALN = fd(11, .{ .Varint = .Simple }), + .MMIJLNONOOI = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMHNEDALDFF = struct { + retcode: u32 = 0, + MMIJLNONOOI: u32 = 0, + PMLHOJDLOCP: ?AHFHPCFBJNE = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .MMIJLNONOOI = fd(13, .{ .Varint = .Simple }), + .PMLHOJDLOCP = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIHOKPJOOGJ = struct { + KJFLOGLHFPH: u32 = 0, + + pub const _desc_table = .{ + .KJFLOGLHFPH = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOOEIGPBHJH = struct { + KJFLOGLHFPH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .KJFLOGLHFPH = fd(4, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ACNANDDHPEJ = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFIOANCDPJO = struct { + retcode: u32 = 0, + battle_info: ?GFOBLINGFBL = null, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .battle_info = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJNDACJIKBO = struct { + lineup: ?JNHMIOGHAEG = null, + + pub const _desc_table = .{ + .lineup = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAMAGFKLIID = struct { + MMIJLNONOOI: u32 = 0, + PMLHOJDLOCP: ?AHFHPCFBJNE = null, + OGACFCNJFPL: ArrayList(AHFHPCFBJNE), + + pub const _desc_table = .{ + .MMIJLNONOOI = fd(1, .{ .Varint = .Simple }), + .PMLHOJDLOCP = fd(2, .{ .SubMessage = {} }), + .OGACFCNJFPL = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCPGBIHOOLC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BGOIDJFMCJG = struct { + FIBDNGJJDFD: u32 = 0, + retcode: u32 = 0, + EELDBMONEIM: ArrayList(u32), + NKOPMKCNIFO: ArrayList(u32), + + pub const _desc_table = .{ + .FIBDNGJJDFD = fd(5, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + .EELDBMONEIM = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .NKOPMKCNIFO = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNHIAGOCNFN = struct { + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHHAOLNAIAF = struct { + KFBJEFGKIPH: u32 = 0, + + pub const _desc_table = .{ + .KFBJEFGKIPH = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDKBHECOLDG = struct { + NHFGFOCFGCG: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(3, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKKNHEKNNLD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IDENHCHOOGD = struct { + OHIMLBKKODO: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .OHIMLBKKODO = fd(14, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFGHLBJHKKJ = struct { + OHIMLBKKODO: u32 = 0, + + pub const _desc_table = .{ + .OHIMLBKKODO = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIGFBOIFKLP = struct { + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHFHFAJJMIH = struct { + retcode: u32 = 0, + LGNHDNODOLM: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .LGNHDNODOLM = fd(2, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKDJMHNBGFO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOKDLOCCIAD = struct { + EGKOJHEIOHH: u32 = 0, + KGBBGKJKIDC: u32 = 0, + + pub const _desc_table = .{ + .EGKOJHEIOHH = fd(11, .{ .Varint = .Simple }), + .KGBBGKJKIDC = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OGMKGCIOPJF = struct { + level: u32 = 0, + OJCFOBHCBHK: u32 = 0, + + pub const _desc_table = .{ + .level = fd(7, .{ .Varint = .Simple }), + .OJCFOBHCBHK = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMCFKOHNIHB = struct { + GGEFBDOKDDD: ArrayList(LogisticsScore), + PMADKOCEBFN: ArrayList(IOKDLOCCIAD), + JDOIHHNHKPM: ArrayList(u32), + IMBIDBLABGN: ArrayList(IKOJNMFAADM), + + pub const _desc_table = .{ + .GGEFBDOKDDD = fd(15, .{ .List = .{ .SubMessage = {} } }), + .PMADKOCEBFN = fd(8, .{ .List = .{ .SubMessage = {} } }), + .JDOIHHNHKPM = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .IMBIDBLABGN = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJBIECGMJMD = struct { + FIFHMONIDBL: ?DMCFKOHNIHB = null, + KHOFMPHEFNC: ArrayList(NABCIIFFDCE), + EBNNBEEGJFN: u32 = 0, + KFHDOFNDNAH: ArrayList(u32), + IGOGPLHKHDA: ?IKBABPKIKAF = null, + PCFBNFBDLAH: ArrayList(PCFBNFBDLAHEntry), + EIFJOOEEELK: ArrayList(u32), + CDMHBJPKLJO: ?OHAJNAEBFCO = null, + level: u32 = 0, + POLIIKOPAEB: u32 = 0, + retcode: u32 = 0, + CCJNIIDBKCE: ArrayList(u32), + + pub const _desc_table = .{ + .FIFHMONIDBL = fd(6, .{ .SubMessage = {} }), + .KHOFMPHEFNC = fd(7, .{ .List = .{ .SubMessage = {} } }), + .EBNNBEEGJFN = fd(12, .{ .Varint = .Simple }), + .KFHDOFNDNAH = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .IGOGPLHKHDA = fd(5, .{ .SubMessage = {} }), + .PCFBNFBDLAH = fd(8, .{ .List = .{ .SubMessage = {} } }), + .EIFJOOEEELK = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .CDMHBJPKLJO = fd(3, .{ .SubMessage = {} }), + .level = fd(10, .{ .Varint = .Simple }), + .POLIIKOPAEB = fd(11, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .CCJNIIDBKCE = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub const PCFBNFBDLAHEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FABACBMEOPI = struct { + APALNNDOBMI: u32 = 0, + LINIEAIBABI: u32 = 0, + + pub const _desc_table = .{ + .APALNNDOBMI = fd(14, .{ .Varint = .Simple }), + .LINIEAIBABI = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLFAJABOOBL = struct { + AALFIHNDABH: u32 = 0, + OIJIOBICLJG: ArrayList(FABACBMEOPI), + + pub const _desc_table = .{ + .AALFIHNDABH = fd(15, .{ .Varint = .Simple }), + .OIJIOBICLJG = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AlleyPlacingShip = struct { + ship_id: u32 = 0, + goods_list: ArrayList(LLFAJABOOBL), + + pub const _desc_table = .{ + .ship_id = fd(4, .{ .Varint = .Simple }), + .goods_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APEOHEAIJKN = struct { + JMAIKKKNCLA: u32 = 0, + IEPKPGBMBLA: u32 = 0, + LBLLCLNHCND: u32 = 0, + NFKNELJBBML: u32 = 0, + AHCCGGOECLA: u32 = 0, + DFCIJPEFOKP: u32 = 0, + cost_time: u32 = 0, + JDHMPJKBHIL: u32 = 0, + DFNHEIDEEHM: ?AlleyPlacingShip = null, + + pub const _desc_table = .{ + .JMAIKKKNCLA = fd(4, .{ .Varint = .Simple }), + .IEPKPGBMBLA = fd(5, .{ .Varint = .Simple }), + .LBLLCLNHCND = fd(7, .{ .Varint = .Simple }), + .NFKNELJBBML = fd(15, .{ .Varint = .Simple }), + .AHCCGGOECLA = fd(12, .{ .Varint = .Simple }), + .DFCIJPEFOKP = fd(9, .{ .Varint = .Simple }), + .cost_time = fd(8, .{ .Varint = .Simple }), + .JDHMPJKBHIL = fd(1, .{ .Varint = .Simple }), + .DFNHEIDEEHM = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMBOKGDPBHN = struct { + retcode: u32 = 0, + PLEEAEICDHL: u32 = 0, + BGMHIMAADKO: u32 = 0, + ANKNEJNJMPH: u32 = 0, + FJKIOLLNNIM: u32 = 0, + KKMOLANKIMM: u32 = 0, + ECLPCAEIGII: u32 = 0, + event_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .PLEEAEICDHL = fd(12, .{ .Varint = .Simple }), + .BGMHIMAADKO = fd(10, .{ .Varint = .Simple }), + .ANKNEJNJMPH = fd(2, .{ .Varint = .Simple }), + .FJKIOLLNNIM = fd(14, .{ .Varint = .Simple }), + .KKMOLANKIMM = fd(13, .{ .Varint = .Simple }), + .ECLPCAEIGII = fd(8, .{ .Varint = .Simple }), + .event_id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHAJNAEBFCO = struct { + NNJGPNFNENA: ArrayList(u32), + DEKHELNPCAM: bool = false, + KIBEEKLHMBI: u32 = 0, + AEEFHDJMEGD: ArrayList(u32), + NEOIBJKPKKF: u32 = 0, + HICGMJNEMDL: u32 = 0, + + pub const _desc_table = .{ + .NNJGPNFNENA = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .DEKHELNPCAM = fd(6, .{ .Varint = .Simple }), + .KIBEEKLHMBI = fd(15, .{ .Varint = .Simple }), + .AEEFHDJMEGD = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .NEOIBJKPKKF = fd(8, .{ .Varint = .Simple }), + .HICGMJNEMDL = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHFKDIHLKNM = struct { + FGKLACPMJPH: ?OHAJNAEBFCO = null, + + pub const _desc_table = .{ + .FGKLACPMJPH = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFFDFAFAPDH = struct { + ACMMNKAEHCP: u32 = 0, + + pub const _desc_table = .{ + .ACMMNKAEHCP = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GCJDDFIKFOM = struct { + ABCPFEPKDNH: ArrayList(u32), + OJCFOBHCBHK: u32 = 0, + LGMJJNCNDGP: u32 = 0, + CDMJDJCKDNB: u32 = 0, + CFKBFHCPFLB: ArrayList(u32), + DPAHDBABNJH: ArrayList(u32), + EICDHEPMPOL: u32 = 0, + + pub const _desc_table = .{ + .ABCPFEPKDNH = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .OJCFOBHCBHK = fd(1, .{ .Varint = .Simple }), + .LGMJJNCNDGP = fd(11, .{ .Varint = .Simple }), + .CDMJDJCKDNB = fd(15, .{ .Varint = .Simple }), + .CFKBFHCPFLB = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .DPAHDBABNJH = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .EICDHEPMPOL = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKOJNMFAADM = struct { + AEMNBEMKIED: ArrayList(GCJDDFIKFOM), + EGKOJHEIOHH: u32 = 0, + cost_time: u32 = 0, + + pub const _desc_table = .{ + .AEMNBEMKIED = fd(14, .{ .List = .{ .SubMessage = {} } }), + .EGKOJHEIOHH = fd(3, .{ .Varint = .Simple }), + .cost_time = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LogisticsScore = struct { + last_level: u32 = 0, + max_score: u32 = 0, + reward: ?ItemList = null, + last_max_score: u32 = 0, + map_id: u32 = 0, + UnlockLevel: u32 = 0, + cur_score: u32 = 0, + + pub const _desc_table = .{ + .last_level = fd(6, .{ .Varint = .Simple }), + .max_score = fd(8, .{ .Varint = .Simple }), + .reward = fd(4, .{ .SubMessage = {} }), + .last_max_score = fd(1, .{ .Varint = .Simple }), + .map_id = fd(11, .{ .Varint = .Simple }), + .UnlockLevel = fd(14, .{ .Varint = .Simple }), + .cur_score = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CCANDKFFEJE = struct { + KCNEONLNDMF: bool = false, + BHOAKBMNAHJ: ArrayList(IKOJNMFAADM), + + pub const _desc_table = .{ + .KCNEONLNDMF = fd(15, .{ .Varint = .Simple }), + .BHOAKBMNAHJ = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMPKMLLOHJK = struct { + GGEFBDOKDDD: ArrayList(LogisticsScore), + + pub const _desc_table = .{ + .GGEFBDOKDDD = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJEHCICEPJH = struct { + GGEFBDOKDDD: ArrayList(LogisticsScore), + event_id: u32 = 0, + retcode: u32 = 0, + KCNEONLNDMF: bool = false, + + pub const _desc_table = .{ + .GGEFBDOKDDD = fd(8, .{ .List = .{ .SubMessage = {} } }), + .event_id = fd(11, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + .KCNEONLNDMF = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NABCIIFFDCE = struct { + HIJDBKAPIFE: u32 = 0, + state: OGAOBHGMLBH = @enumFromInt(0), + event_id: u32 = 0, + + pub const _desc_table = .{ + .HIJDBKAPIFE = fd(6, .{ .Varint = .Simple }), + .state = fd(10, .{ .Varint = .Simple }), + .event_id = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJCDFLMJKPE = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMAGFMGPFHH = struct { + event_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(1, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDIJGKOMLHE = struct { + PACNBJIPIGF: u32 = 0, + ABBCLHGLMHI: ?NABCIIFFDCE = null, + + pub const _desc_table = .{ + .PACNBJIPIGF = fd(14, .{ .Varint = .Simple }), + .ABBCLHGLMHI = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNAIGOAOBNK = struct { + AAGLGLPDIKN: u32 = 0, + + pub const _desc_table = .{ + .AAGLGLPDIKN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DDBJHAOPMKN = struct { + level: u32 = 0, + + pub const _desc_table = .{ + .level = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOJCGHEOMJD = struct { + level: u32 = 0, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .level = fd(9, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDCAKJIKAGP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEPJLBNEPMI = struct { + retcode: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .level = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGLPMANOLPI = struct { + EBNNBEEGJFN: u32 = 0, + + pub const _desc_table = .{ + .EBNNBEEGJFN = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLFADGNNBJB = struct { + BHOAKBMNAHJ: ArrayList(IKOJNMFAADM), + + pub const _desc_table = .{ + .BHOAKBMNAHJ = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HIJHDEHAACH = struct { + BHOAKBMNAHJ: ArrayList(IKOJNMFAADM), + retcode: u32 = 0, + + pub const _desc_table = .{ + .BHOAKBMNAHJ = fd(3, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GAIHOLEEJDF = struct { + FIFHMONIDBL: ?DMCFKOHNIHB = null, + + pub const _desc_table = .{ + .FIFHMONIDBL = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKBABPKIKAF = struct { + IMKGOBNFLFH: u32 = 0, + GIDAGDJBFOK: ArrayList(GIDAGDJBFOKEntry), + OIDPOJKLPLK: u32 = 0, + + pub const _desc_table = .{ + .IMKGOBNFLFH = fd(5, .{ .Varint = .Simple }), + .GIDAGDJBFOK = fd(3, .{ .List = .{ .SubMessage = {} } }), + .OIDPOJKLPLK = fd(8, .{ .Varint = .Simple }), + }; + + pub const GIDAGDJBFOKEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLHMLKNJKNO = struct { + IHMEGBONCNF: ?IKBABPKIKAF = null, + + pub const _desc_table = .{ + .IHMEGBONCNF = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLMKPCNHMKP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GLIAOOOPIII = struct { + retcode: u32 = 0, + IMBIDBLABGN: ArrayList(IKOJNMFAADM), + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .IMBIDBLABGN = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJIBONEEJAE = struct { + PCFBNFBDLAH: ArrayList(PCFBNFBDLAHEntry), + + pub const _desc_table = .{ + .PCFBNFBDLAH = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const PCFBNFBDLAHEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NAKPEHPLHFJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFHJMMAOHKI = struct { + retcode: u32 = 0, + JHBFHIGHGBC: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .JHBFHIGHGBC = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALOHIMGIBJN = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOLOPEELEGK = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(3, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHMOJKFEKOB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMEFIHPGGCC = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AIJINNKBPBM = struct { + EDALKPMNHGB: u32 = 0, + EEOLCCFMJFF: u32 = 0, + + pub const _desc_table = .{ + .EDALKPMNHGB = fd(13, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIAKMCBFHGN = struct { + NHFGFOCFGCG: u32 = 0, + monster_id: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(2, .{ .Varint = .Simple }), + .monster_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OGFBEGPJKDA = struct { + KGPEPODICNB: ArrayList(u32), + relic_list: ArrayList(AIJINNKBPBM), + POJIKOANPIA: ArrayList(EIAKMCBFHGN), + CEHLHKJLCKN: ArrayList(u32), + HJFHCODEIJJ: ArrayList(u32), + + pub const _desc_table = .{ + .KGPEPODICNB = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .relic_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + .POJIKOANPIA = fd(11, .{ .List = .{ .SubMessage = {} } }), + .CEHLHKJLCKN = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .HJFHCODEIJJ = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHFFHHFHBBD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EICMPAJPJIP = struct { + ELGFAMHCBAG: ?OGFBEGPJKDA = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ELGFAMHCBAG = fd(1, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKNCEMGKKCA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GEPBKDHIFOF = struct { + retcode: u32 = 0, + ELGFAMHCBAG: ?OGFBEGPJKDA = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .ELGFAMHCBAG = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetAvatarDataCsReq = struct { + is_get_all: bool = false, + base_avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .is_get_all = fd(12, .{ .Varint = .Simple }), + .base_avatar_id_list = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EquipRelic = struct { + IPALMPODPOF: u32 = 0, + EEOLCCFMJFF: u32 = 0, + + pub const _desc_table = .{ + .IPALMPODPOF = fd(14, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Avatar = struct { + rank: u32 = 0, + promotion: u32 = 0, + first_met_timestamp: u64 = 0, + LIEMECDNPEL: u32 = 0, + exp: u32 = 0, + HLPGKBDIEHL: ArrayList(EquipRelic), + base_avatar_id: u32 = 0, + KFDOAHPKDMC: bool = false, + skilltree_list: ArrayList(AvatarSkillTree), + IDGAGNIFBNF: ArrayList(u32), + level: u32 = 0, + JBENGPDOLHH: u32 = 0, + + pub const _desc_table = .{ + .rank = fd(1, .{ .Varint = .Simple }), + .promotion = fd(12, .{ .Varint = .Simple }), + .first_met_timestamp = fd(8, .{ .Varint = .Simple }), + .LIEMECDNPEL = fd(7, .{ .Varint = .Simple }), + .exp = fd(15, .{ .Varint = .Simple }), + .HLPGKBDIEHL = fd(14, .{ .List = .{ .SubMessage = {} } }), + .base_avatar_id = fd(13, .{ .Varint = .Simple }), + .KFDOAHPKDMC = fd(3, .{ .Varint = .Simple }), + .skilltree_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + .IDGAGNIFBNF = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .level = fd(5, .{ .Varint = .Simple }), + .JBENGPDOLHH = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetAvatarDataScRsp = struct { + avatar_list: ArrayList(Avatar), + AHNMAIFFHDE: ArrayList(u32), + is_all: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .avatar_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + .AHNMAIFFHDE = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .is_all = fd(14, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKDKKCJJANF = struct { + base_avatar_id: u32 = 0, + ICALKDAJDAM: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .base_avatar_id = fd(12, .{ .Varint = .Simple }), + .ICALKDAJDAM = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJHOKJEMJON = struct { + retcode: u32 = 0, + DIFKMAGCOIG: ArrayList(PileItem), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .DIFKMAGCOIG = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMBHNEKAHIN = struct { + point_id: u32 = 0, + LHFFLOKIELE: ArrayList(ItemCost), + level: u32 = 0, + + pub const _desc_table = .{ + .point_id = fd(12, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(6, .{ .List = .{ .SubMessage = {} } }), + .level = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLBDCOHFKIO = struct { + point_id: u32 = 0, + level: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .point_id = fd(15, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMHHOCFKMGM = struct { + point_id: u32 = 0, + LHFFLOKIELE: ArrayList(ItemCost), + level: u32 = 0, + + pub const _desc_table = .{ + .point_id = fd(3, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(4, .{ .List = .{ .SubMessage = {} } }), + .level = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABKDFBFJFOP = struct { + level: u32 = 0, + point_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .level = fd(10, .{ .Varint = .Simple }), + .point_id = fd(5, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCBEBKMCBAA = struct { + point_id: ArrayList(u32), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .point_id = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCJMOLLONPB = struct { + HHNCLLLAJCG: ArrayList(DCBEBKMCBAA), + + pub const _desc_table = .{ + .HHNCLLLAJCG = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNPPJNNGJNP = struct { + LHFFLOKIELE: ArrayList(ItemCost), + base_avatar_id: u32 = 0, + + pub const _desc_table = .{ + .LHFFLOKIELE = fd(4, .{ .List = .{ .SubMessage = {} } }), + .base_avatar_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHDLBGAFDCB = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIGKJOOGFLH = struct { + avatar_id: u32 = 0, + LIEMECDNPEL: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(2, .{ .Varint = .Simple }), + .LIEMECDNPEL = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKDGFBBMLAP = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMLNDICHCNB = struct { + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNECKDGALMN = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICLBEPINAIP = struct { + ADKJIIANOOM: ?ItemList = null, + FHFIGBKCGIF: bool = false, + PBHPBJHMGPI: AddAvatarSrc = @enumFromInt(0), + base_avatar_id: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(15, .{ .SubMessage = {} }), + .FHFIGBKCGIF = fd(9, .{ .Varint = .Simple }), + .PBHPBJHMGPI = fd(7, .{ .Varint = .Simple }), + .base_avatar_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODEOMIODPHK = struct { + rank: u32 = 0, + HFBKPOBHBIM: ?PEHCKCFABKB = null, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .rank = fd(1, .{ .Varint = .Simple }), + .HFBKPOBHBIM = fd(2, .{ .SubMessage = {} }), + .avatar_id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDNEOHHDOOF = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFDDAKCMLLK = struct { + IPALMPODPOF: u32 = 0, + KHOMKOOMIJC: u32 = 0, + + pub const _desc_table = .{ + .IPALMPODPOF = fd(11, .{ .Varint = .Simple }), + .KHOMKOOMIJC = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHHDIKAJPJM = struct { + param_list: ArrayList(NFDDAKCMLLK), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .param_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .avatar_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPMBFIJLMAD = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DEDEEHAILAB = struct { + NDOPAEIOICN: ArrayList(u32), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .NDOPAEIOICN = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCNDDGJIGOF = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBOKIFEBEBP = struct { + promotion: u32 = 0, + base_avatar_id: u32 = 0, + + pub const _desc_table = .{ + .promotion = fd(15, .{ .Varint = .Simple }), + .base_avatar_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPOFAEJJJOI = struct { + EADGDKMCPCI: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EADGDKMCPCI = fd(1, .{ .SubMessage = {} }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIEHNIOLPAD = struct { + FCKCGJEKDFJ: u32 = 0, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .FCKCGJEKDFJ = fd(15, .{ .Varint = .Simple }), + .avatar_id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBBDNGOBDIN = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLEOJFHMOHN = struct { + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCIBNKCOMOG = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGNILLDGAIP = struct { + FCKCGJEKDFJ: u32 = 0, + + pub const _desc_table = .{ + .FCKCGJEKDFJ = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMFCHPAGKFM = struct { + avatar_id: u32 = 0, + KFDOAHPKDMC: bool = false, + + pub const _desc_table = .{ + .avatar_id = fd(6, .{ .Varint = .Simple }), + .KFDOAHPKDMC = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFPMBPDLNLN = struct { + avatar_id: u32 = 0, + KFDOAHPKDMC: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(6, .{ .Varint = .Simple }), + .KFDOAHPKDMC = fd(3, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PVEBattleResultCsReq = struct { + AJDGHADCPGM: u32 = 0, + stt: ?BattleStatistics = null, + op_list: ArrayList(BattleOp), + end_status: BattleEndStatus = @enumFromInt(0), + HNAFEOKONDB: bool = false, + is_auto_fight: bool = false, + KEAPPFOFEJI: u32 = 0, + turn_snapshot_hash: ManagedString = .Empty, + stage_id: u32 = 0, + cost_time: u32 = 0, + ONILONJFBHO: ArrayList(ONILONJFBHOEntry), + BEMCMDMLHMC: u32 = 0, + IADAODPBPGO: ManagedString = .Empty, + is_ai_consider_ultra_skill: bool = false, + battle_id: u32 = 0, + + pub const _desc_table = .{ + .AJDGHADCPGM = fd(7, .{ .Varint = .Simple }), + .stt = fd(5, .{ .SubMessage = {} }), + .op_list = fd(8, .{ .List = .{ .SubMessage = {} } }), + .end_status = fd(9, .{ .Varint = .Simple }), + .HNAFEOKONDB = fd(15, .{ .Varint = .Simple }), + .is_auto_fight = fd(1, .{ .Varint = .Simple }), + .KEAPPFOFEJI = fd(2, .{ .Varint = .Simple }), + .turn_snapshot_hash = fd(11, .String), + .stage_id = fd(6, .{ .Varint = .Simple }), + .cost_time = fd(13, .{ .Varint = .Simple }), + .ONILONJFBHO = fd(10, .{ .List = .{ .SubMessage = {} } }), + .BEMCMDMLHMC = fd(14, .{ .Varint = .Simple }), + .IADAODPBPGO = fd(4, .String), + .is_ai_consider_ultra_skill = fd(12, .{ .Varint = .Simple }), + .battle_id = fd(3, .{ .Varint = .Simple }), + }; + + pub const ONILONJFBHOEntry = struct { + key: ManagedString = .Empty, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PVEBattleResultScRsp = struct { + CEGPOLNEFJE: ?ItemList = null, + event_id: u32 = 0, + battle_avatar_list: ArrayList(BattleAvatar), + NPCJHAMADCD: ?ItemList = null, + ENODKAHIHML: ?ItemList = null, + PBOCDDMPGLP: bool = false, + IEOHEALBOKF: u32 = 0, + retcode: u32 = 0, + BMDDLNBLHFI: ManagedString = .Empty, + JNGBOEKJPAG: ?ItemList = null, + battle_id: u32 = 0, + mismatch_turn_count: u32 = 0, + BIJCMDFOJML: ManagedString = .Empty, + end_status: BattleEndStatus = @enumFromInt(0), + IAFPGFMHPCJ: u32 = 0, + stage_id: u32 = 0, + + pub const _desc_table = .{ + .CEGPOLNEFJE = fd(6, .{ .SubMessage = {} }), + .event_id = fd(3, .{ .Varint = .Simple }), + .battle_avatar_list = fd(11, .{ .List = .{ .SubMessage = {} } }), + .NPCJHAMADCD = fd(1822, .{ .SubMessage = {} }), + .ENODKAHIHML = fd(14, .{ .SubMessage = {} }), + .PBOCDDMPGLP = fd(1, .{ .Varint = .Simple }), + .IEOHEALBOKF = fd(9, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + .BMDDLNBLHFI = fd(12, .String), + .JNGBOEKJPAG = fd(5, .{ .SubMessage = {} }), + .battle_id = fd(10, .{ .Varint = .Simple }), + .mismatch_turn_count = fd(2, .{ .Varint = .Simple }), + .BIJCMDFOJML = fd(15, .String), + .end_status = fd(7, .{ .Varint = .Simple }), + .IAFPGFMHPCJ = fd(13, .{ .Varint = .Simple }), + .stage_id = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGDOPKBJHFG = struct { + COEMOEECAEM: OICCDGCAPKG = @enumFromInt(0), + stt: ?BattleStatistics = null, + + pub const _desc_table = .{ + .COEMOEECAEM = fd(8, .{ .Varint = .Simple }), + .stt = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELBEIBMHMHL = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GPHIBADFPAE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKFMHBCPJJO = struct { + LPNDBCIPNMF: BattleEndStatus = @enumFromInt(0), + IEHJLCMNKBB: u32 = 0, + retcode: u32 = 0, + ABBCICNNNJH: ?GFOBLINGFBL = null, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .LPNDBCIPNMF = fd(1, .{ .Varint = .Simple }), + .IEHJLCMNKBB = fd(4, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + .ABBCICNNNJH = fd(10, .{ .SubMessage = {} }), + .battle_info = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBGJHNFHCFD = struct { + AJDGHADCPGM: u32 = 0, + + pub const _desc_table = .{ + .AJDGHADCPGM = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const INABPDLLHMH = struct { + retcode: u32 = 0, + AJDGHADCPGM: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .AJDGHADCPGM = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLOIDPMCJGJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBEJNCAMLDN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BIKBFMALBPI = struct { + KOLEGOGOOJB: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .KOLEGOGOOJB = fd(6, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBDMOAPFMGP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PFNKBCDFMAN = struct { + FAOBCNGOEFD: bool = false, + + pub const _desc_table = .{ + .FAOBCNGOEFD = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKCEBKJGEIG = struct { + stt: ?BattleStatistics = null, + COEMOEECAEM: OICCDGCAPKG = @enumFromInt(0), + + pub const _desc_table = .{ + .stt = fd(11, .{ .SubMessage = {} }), + .COEMOEECAEM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LOGFHDOKODE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LKGLMJBAMFO = struct { + retcode: u32 = 0, + GDHAHHNGJBI: ArrayList(u32), + OKGJGNDJIDE: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .GDHAHHNGJBI = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .OKGJGNDJIDE = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDJLOOOIHLE = struct { + OKGJGNDJIDE: u32 = 0, + GDHAHHNGJBI: ArrayList(u32), + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .OKGJGNDJIDE = fd(13, .{ .Varint = .Simple }), + .GDHAHHNGJBI = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .ADKJIIANOOM = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDOMPMCDEIB = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANNIDKMLELB = struct { + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .battle_info = fd(15, .{ .SubMessage = {} }), + .id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANJBDEIOKJA = struct { + BDAOALGKNBK: OFMFCLIFILH = @enumFromInt(0), + GIOMIAJHILJ: u64 = 0, + exp: u32 = 0, + PCMOMDCFGOJ: u32 = 0, + LGEHFCAGIJA: u64 = 0, + JDFEAHLAFPB: u32 = 0, + NAPNJDHFMGG: u64 = 0, + BEBHPJNNGIC: u64 = 0, + KGMNLHNEINE: u64 = 0, + KPMLMBJJMJJ: u64 = 0, + level: u32 = 0, + IEJJHJHIAGP: u64 = 0, + CLJFNACHIPK: u64 = 0, + + pub const _desc_table = .{ + .BDAOALGKNBK = fd(5, .{ .Varint = .Simple }), + .GIOMIAJHILJ = fd(15, .{ .Varint = .Simple }), + .exp = fd(12, .{ .Varint = .Simple }), + .PCMOMDCFGOJ = fd(1, .{ .Varint = .Simple }), + .LGEHFCAGIJA = fd(10, .{ .Varint = .Simple }), + .JDFEAHLAFPB = fd(14, .{ .Varint = .Simple }), + .NAPNJDHFMGG = fd(6, .{ .Varint = .Simple }), + .BEBHPJNNGIC = fd(11, .{ .Varint = .Simple }), + .KGMNLHNEINE = fd(2, .{ .Varint = .Simple }), + .KPMLMBJJMJJ = fd(7, .{ .Varint = .Simple }), + .level = fd(4, .{ .Varint = .Simple }), + .IEJJHJHIAGP = fd(8, .{ .Varint = .Simple }), + .CLJFNACHIPK = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FFCLAIFDAIG = struct { + IDONMCFMCBE: u32 = 0, + level: u32 = 0, + EEOLCCFMJFF: HEFEKEALDNH = @enumFromInt(0), + + pub const _desc_table = .{ + .IDONMCFMCBE = fd(12, .{ .Varint = .Simple }), + .level = fd(1, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMOGHNEDKJH = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(4, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGDCNHPLGNN = struct { + ODGBCOIGIGD: u32 = 0, + + pub const _desc_table = .{ + .ODGBCOIGIGD = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GAFGHEMPLGH = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OptionalReward = struct { + optional_reward_id: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .optional_reward_id = fd(12, .{ .Varint = .Simple }), + .level = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBNELOIBOOI = struct { + CFFAGOLLGNO: ArrayList(OptionalReward), + + pub const _desc_table = .{ + .CFFAGOLLGNO = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEOMNAJEOFG = struct { + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IAIGAHOCLKG = struct { + avatar_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(2, .{ .Varint = .Simple }), + .avatar_type = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBIOGLAJFGC = struct { + avatar_list: ArrayList(u32), + LGNHDNODOLM: u32 = 0, + DBFFJFJLGMI: u32 = 0, + KJFODDOIOOH: u32 = 0, + HCMHHHBFKKK: bool = false, + LKMMFCOMHEO: ArrayList(u32), + NELFNFOIGDO: u32 = 0, + GDACDANJJJI: u32 = 0, + ECNHLFPGILE: u32 = 0, + BGKMPKEMOJC: ArrayList(IAIGAHOCLKG), + + pub const _desc_table = .{ + .avatar_list = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .LGNHDNODOLM = fd(12, .{ .Varint = .Simple }), + .DBFFJFJLGMI = fd(15, .{ .Varint = .Simple }), + .KJFODDOIOOH = fd(2, .{ .Varint = .Simple }), + .HCMHHHBFKKK = fd(8, .{ .Varint = .Simple }), + .LKMMFCOMHEO = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .NELFNFOIGDO = fd(13, .{ .Varint = .Simple }), + .GDACDANJJJI = fd(4, .{ .Varint = .Simple }), + .ECNHLFPGILE = fd(3, .{ .Varint = .Simple }), + .BGKMPKEMOJC = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DKJDLGIIEJF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBBDDKHPFGM = struct { + NIKHKCMAFMM: ArrayList(OBIOGLAJFGC), + retcode: u32 = 0, + + pub const _desc_table = .{ + .NIKHKCMAFMM = fd(15, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFBOFLCJAEL = struct { + avatar_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(5, .{ .Varint = .Simple }), + .avatar_type = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBADDAHPPGJ = struct { + avatar_list: ArrayList(u32), + LGNHDNODOLM: u32 = 0, + BGKMPKEMOJC: ArrayList(EFBOFLCJAEL), + + pub const _desc_table = .{ + .avatar_list = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .LGNHDNODOLM = fd(8, .{ .Varint = .Simple }), + .BGKMPKEMOJC = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CDDECHMPEGK = struct { + GHPNGHINJBH: ?OBIOGLAJFGC = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GHPNGHINJBH = fd(8, .{ .SubMessage = {} }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLNHCDGPNIP = struct { + LGNHDNODOLM: u32 = 0, + NELFNFOIGDO: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(2, .{ .Varint = .Simple }), + .NELFNFOIGDO = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBJDDHHGPNF = struct { + retcode: u32 = 0, + GHPNGHINJBH: ?OBIOGLAJFGC = null, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .GHPNGHINJBH = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HMKGIOEKCEH = struct { + BGKMPKEMOJC: ArrayList(EFBOFLCJAEL), + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .BGKMPKEMOJC = fd(12, .{ .List = .{ .SubMessage = {} } }), + .LGNHDNODOLM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKENIMKJEDL = struct { + retcode: u32 = 0, + GHPNGHINJBH: ?OBIOGLAJFGC = null, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .GHPNGHINJBH = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FHBNAFDCHLI = struct { + LGNHDNODOLM: u32 = 0, + CLECDGLHEHC: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(11, .{ .Varint = .Simple }), + .CLECDGLHEHC = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MLBEIIDNIPA = struct { + retcode: u32 = 0, + GHPNGHINJBH: ?OBIOGLAJFGC = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .GHPNGHINJBH = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGHNDHJNJDG = struct { + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKLCJKIAPBF = struct { + LGNHDNODOLM: u32 = 0, + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(7, .{ .Varint = .Simple }), + .battle_info = fd(2, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJCJKEKEGFB = struct { + LGNHDNODOLM: u32 = 0, + DANADLDDKHJ: bool = false, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(14, .{ .Varint = .Simple }), + .DANADLDDKHJ = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLIFLLMECIN = struct { + GHPNGHINJBH: ?OBIOGLAJFGC = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GHPNGHINJBH = fd(11, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPIAAHNIJME = struct { + DBFFJFJLGMI: u32 = 0, + LDAMNJPGJOC: bool = false, + ADKJIIANOOM: ?ItemList = null, + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .DBFFJFJLGMI = fd(4, .{ .Varint = .Simple }), + .LDAMNJPGJOC = fd(2, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(9, .{ .SubMessage = {} }), + .LGNHDNODOLM = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDGFDEPFMHH = struct { + GHPNGHINJBH: ?OBIOGLAJFGC = null, + + pub const _desc_table = .{ + .GHPNGHINJBH = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OEKIEIHHJBC = struct { + FODNLHANPGH: u32 = 0, + GKGOKJJGINE: ?LMJLNMPCJJA = null, + LAKPOEKFOFH: u32 = 0, + HEMJIDNEAHO: u32 = 0, + AHNJDLJONFO: bool = false, + LGNHDNODOLM: u32 = 0, + FDDOLEGBPHH: u32 = 0, + LMAIBMPOCDD: u32 = 0, + + pub const _desc_table = .{ + .FODNLHANPGH = fd(4, .{ .Varint = .Simple }), + .GKGOKJJGINE = fd(3, .{ .SubMessage = {} }), + .LAKPOEKFOFH = fd(6, .{ .Varint = .Simple }), + .HEMJIDNEAHO = fd(14, .{ .Varint = .Simple }), + .AHNJDLJONFO = fd(13, .{ .Varint = .Simple }), + .LGNHDNODOLM = fd(5, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(1, .{ .Varint = .Simple }), + .LMAIBMPOCDD = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EANDEHFDNOJ = struct { + HNNKPCBMIKN: u64 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .HNNKPCBMIKN = fd(5, .{ .Varint = .Simple }), + .group_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMHNANJAINM = struct { + MIKJCKGDJCK: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .MIKJCKGDJCK = fd(3, .{ .Varint = .Simple }), + .level = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDBBBNOOLDA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKEDBNMDBOG = struct { + NGPBPLPBLNE: ArrayList(EANDEHFDNOJ), + NIKHKCMAFMM: ArrayList(OEKIEIHHJBC), + OKGCOBHLIIM: u32 = 0, + BCGCOGHPHPP: ArrayList(NMHNANJAINM), + retcode: u32 = 0, + + pub const _desc_table = .{ + .NGPBPLPBLNE = fd(4, .{ .List = .{ .SubMessage = {} } }), + .NIKHKCMAFMM = fd(9, .{ .List = .{ .SubMessage = {} } }), + .OKGCOBHLIIM = fd(8, .{ .Varint = .Simple }), + .BCGCOGHPHPP = fd(2, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGNHNMBDGDP = struct { + ANGCCKJMBBG: u32 = 0, + KAGFGNKJPOA: u32 = 0, + + pub const _desc_table = .{ + .ANGCCKJMBBG = fd(10, .{ .Varint = .Simple }), + .KAGFGNKJPOA = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOEHHELMJMJ = struct { + ANGCCKJMBBG: u32 = 0, + KAGFGNKJPOA: u32 = 0, + + pub const _desc_table = .{ + .ANGCCKJMBBG = fd(13, .{ .Varint = .Simple }), + .KAGFGNKJPOA = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DKBCKMJKFPO = struct { + EHAFGOGAFCD: ?DGNHNMBDGDP = null, + AFHJGLGLKHD: ?DOEHHELMJMJ = null, + + pub const _desc_table = .{ + .EHAFGOGAFCD = fd(6, .{ .SubMessage = {} }), + .AFHJGLGLKHD = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FNMAJFMDCEG = struct { + LGNHDNODOLM: u32 = 0, + GKGOKJJGINE: ?DKBCKMJKFPO = null, + CJAKHEMDBKF: ArrayList(u32), + JKCEDLFONKH: ArrayList(u32), + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(3, .{ .Varint = .Simple }), + .GKGOKJJGINE = fd(2, .{ .SubMessage = {} }), + .CJAKHEMDBKF = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .JKCEDLFONKH = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLLACCBLIJF = struct { + scene: ?SceneInfo = null, + GKGOKJJGINE: ?LMJLNMPCJJA = null, + lineup_list: ArrayList(LineupInfo), + OGGFLNBMHIG: ?GKCKOMDIFLP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .scene = fd(11, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(12, .{ .SubMessage = {} }), + .lineup_list = fd(14, .{ .List = .{ .SubMessage = {} } }), + .OGGFLNBMHIG = fd(8, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNAGCIGANAK = struct { + AMAJNGOBNKJ: bool = false, + LGNHDNODOLM: u32 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .AMAJNGOBNKJ = fd(5, .{ .Varint = .Simple }), + .LGNHDNODOLM = fd(10, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPKLLCGOABD = struct { + retcode: u32 = 0, + scene: ?SceneInfo = null, + lineup: ?LineupInfo = null, + OGGFLNBMHIG: ?GKCKOMDIFLP = null, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .scene = fd(1, .{ .SubMessage = {} }), + .lineup = fd(3, .{ .SubMessage = {} }), + .OGGFLNBMHIG = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MELDEHFCFMN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKPJJOLCEJA = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJPPDAINNAJ = struct { + OACCGIKCECI: u32 = 0, + OKGCOBHLIIM: u32 = 0, + LAKPOEKFOFH: u32 = 0, + LDAMNJPGJOC: bool = false, + JCDOIJEJKDH: ArrayList(u32), + LHDFJGBLFNH: ?NMHNANJAINM = null, + LGNHDNODOLM: u32 = 0, + HEMJIDNEAHO: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .OACCGIKCECI = fd(10, .{ .Varint = .Simple }), + .OKGCOBHLIIM = fd(3, .{ .Varint = .Simple }), + .LAKPOEKFOFH = fd(1, .{ .Varint = .Simple }), + .LDAMNJPGJOC = fd(5, .{ .Varint = .Simple }), + .JCDOIJEJKDH = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .LHDFJGBLFNH = fd(13, .{ .SubMessage = {} }), + .LGNHDNODOLM = fd(14, .{ .Varint = .Simple }), + .HEMJIDNEAHO = fd(8, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCBMBCACCLM = struct { + monster_id: u32 = 0, + CEFCPCDPAPO: u32 = 0, + + pub const _desc_table = .{ + .monster_id = fd(9, .{ .Varint = .Simple }), + .CEFCPCDPAPO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAEBHGPHCBL = struct { + buff_list: ArrayList(u32), + + pub const _desc_table = .{ + .buff_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMNKELPFNPF = struct { + FLJEFEIAKFB: u32 = 0, + buff_list: ArrayList(u32), + + pub const _desc_table = .{ + .FLJEFEIAKFB = fd(12, .{ .Varint = .Simple }), + .buff_list = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IMEEDKGJKDB = struct { + JPBFJFCABMP: ?OAEBHGPHCBL = null, + BMLKJCHBIOF: ?MMNKELPFNPF = null, + + pub const _desc_table = .{ + .JPBFJFCABMP = fd(1, .{ .SubMessage = {} }), + .BMLKJCHBIOF = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKCKOMDIFLP = struct { + FDDOLEGBPHH: u32 = 0, + status: ChallengeStatus = @enumFromInt(0), + GKGOKJJGINE: ?IMEEDKGJKDB = null, + LAKPOEKFOFH: u32 = 0, + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + LGNHDNODOLM: u32 = 0, + BJFIGLMOGLF: u32 = 0, + POJIKOANPIA: ArrayList(BCBMBCACCLM), + CNPLCLEKMBJ: u32 = 0, + + pub const _desc_table = .{ + .FDDOLEGBPHH = fd(3, .{ .Varint = .Simple }), + .status = fd(13, .{ .Varint = .Simple }), + .GKGOKJJGINE = fd(9, .{ .SubMessage = {} }), + .LAKPOEKFOFH = fd(12, .{ .Varint = .Simple }), + .extra_lineup_type = fd(7, .{ .Varint = .Simple }), + .LGNHDNODOLM = fd(5, .{ .Varint = .Simple }), + .BJFIGLMOGLF = fd(14, .{ .Varint = .Simple }), + .POJIKOANPIA = fd(15, .{ .List = .{ .SubMessage = {} } }), + .CNPLCLEKMBJ = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HIJMLHCBHNK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIHGNFHADKC = struct { + retcode: u32 = 0, + OGGFLNBMHIG: ?GKCKOMDIFLP = null, + lineup_list: ArrayList(LineupInfo), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .OGGFLNBMHIG = fd(5, .{ .SubMessage = {} }), + .lineup_list = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDAPGCLGBNA = struct { + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + + pub const _desc_table = .{ + .extra_lineup_type = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MHPGCNGNAKG = struct { + group_id: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFLALHNGNBO = struct { + EGLGMIGHCNA: ArrayList(BPANBELGANL), + group_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EGLGMIGHCNA = fd(13, .{ .List = .{ .SubMessage = {} } }), + .group_id = fd(5, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BPANBELGANL = struct { + CKKJMALENOP: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .CKKJMALENOP = fd(11, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPJBPNBCBAL = struct { + FPPNODJIBDG: ?HDCOLGAMCBF = null, + FODNLHANPGH: u32 = 0, + + pub const _desc_table = .{ + .FPPNODJIBDG = fd(10, .{ .SubMessage = {} }), + .FODNLHANPGH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJAPECHBENG = struct { + FODNLHANPGH: u32 = 0, + FPPNODJIBDG: ?DALJHLNFOII = null, + + pub const _desc_table = .{ + .FODNLHANPGH = fd(13, .{ .Varint = .Simple }), + .FPPNODJIBDG = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFBDHLEJDJM = struct { + FODNLHANPGH: u32 = 0, + FPPNODJIBDG: ?ABKDOGOIPBJ = null, + + pub const _desc_table = .{ + .FODNLHANPGH = fd(15, .{ .Varint = .Simple }), + .FPPNODJIBDG = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDCOLGAMCBF = struct { + DKFHAHHJILF: u32 = 0, + BJFIGLMOGLF: u32 = 0, + level: u32 = 0, + lineup_list: ArrayList(NCINPBMHNOF), + + pub const _desc_table = .{ + .DKFHAHHJILF = fd(10, .{ .Varint = .Simple }), + .BJFIGLMOGLF = fd(4, .{ .Varint = .Simple }), + .level = fd(9, .{ .Varint = .Simple }), + .lineup_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DALJHLNFOII = struct { + lineup_list: ArrayList(NCINPBMHNOF), + DKFHAHHJILF: u32 = 0, + ANGCCKJMBBG: u32 = 0, + level: u32 = 0, + KAGFGNKJPOA: u32 = 0, + FDDOLEGBPHH: u32 = 0, + + pub const _desc_table = .{ + .lineup_list = fd(14, .{ .List = .{ .SubMessage = {} } }), + .DKFHAHHJILF = fd(15, .{ .Varint = .Simple }), + .ANGCCKJMBBG = fd(5, .{ .Varint = .Simple }), + .level = fd(8, .{ .Varint = .Simple }), + .KAGFGNKJPOA = fd(2, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABKDOGOIPBJ = struct { + lineup_list: ArrayList(NCINPBMHNOF), + DKFHAHHJILF: u32 = 0, + FDDOLEGBPHH: u32 = 0, + ANGCCKJMBBG: u32 = 0, + KAGFGNKJPOA: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .lineup_list = fd(10, .{ .List = .{ .SubMessage = {} } }), + .DKFHAHHJILF = fd(3, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(15, .{ .Varint = .Simple }), + .ANGCCKJMBBG = fd(8, .{ .Varint = .Simple }), + .KAGFGNKJPOA = fd(9, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCINPBMHNOF = struct { + avatar_list: ArrayList(BHIAOADAHKE), + + pub const _desc_table = .{ + .avatar_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHIAOADAHKE = struct { + id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + index: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .id = fd(8, .{ .Varint = .Simple }), + .avatar_type = fd(13, .{ .Varint = .Simple }), + .index = fd(12, .{ .Varint = .Simple }), + .level = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPEDKLFCFMH = struct { + group_id: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBABMJCIPLN = struct { + retcode: u32 = 0, + group_id: u32 = 0, + ADMPDKACMMP: ?FPJBPNBCBAL = null, + JCEOOEGJKNE: ?MJAPECHBENG = null, + LBKCIKIDLCG: ?EFBDHLEJDJM = null, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .group_id = fd(1, .{ .Varint = .Simple }), + .ADMPDKACMMP = fd(3, .{ .SubMessage = {} }), + .JCEOOEGJKNE = fd(9, .{ .SubMessage = {} }), + .LBKCIKIDLCG = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKCMCGEKIFG = struct { + NOJPMGONLPN: u32 = 0, + LDAMNJPGJOC: bool = false, + EHLAMHMJLFP: bool = false, + FOGBECBDFDM: u32 = 0, + + pub const _desc_table = .{ + .NOJPMGONLPN = fd(9, .{ .Varint = .Simple }), + .LDAMNJPGJOC = fd(7, .{ .Varint = .Simple }), + .EHLAMHMJLFP = fd(1, .{ .Varint = .Simple }), + .FOGBECBDFDM = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMLNHLAGLIP = struct { + promotion: u32 = 0, + unique_id: u32 = 0, + APAMKMIGAOP: u32 = 0, + rank: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .promotion = fd(6, .{ .Varint = .Simple }), + .unique_id = fd(12, .{ .Varint = .Simple }), + .APAMKMIGAOP = fd(4, .{ .Varint = .Simple }), + .rank = fd(10, .{ .Varint = .Simple }), + .level = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGCIMMMLHDM = struct { + level: u32 = 0, + unique_id: u32 = 0, + main_affix_id: u32 = 0, + sub_affix_list: ArrayList(RelicAffix), + APAMKMIGAOP: u32 = 0, + + pub const _desc_table = .{ + .level = fd(9, .{ .Varint = .Simple }), + .unique_id = fd(7, .{ .Varint = .Simple }), + .main_affix_id = fd(10, .{ .Varint = .Simple }), + .sub_affix_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + .APAMKMIGAOP = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBDNIEFPHLE = struct { + IKGIMLHNIPI: ArrayList(IKGIMLHNIPIEntry), + + pub const _desc_table = .{ + .IKGIMLHNIPI = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const IKGIMLHNIPIEntry = struct { + key: u32 = 0, + value: ?MGCIMMMLHDM = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBGPGDMLKAD = struct { + LAHNKMKFGBC: ?OKCMCGEKIFG = null, + INJKDMPMAGB: ?OKCMCGEKIFG = null, + JKCEDLFONKH: ArrayList(u32), + MPHILJEPBDD: ArrayList(MPHILJEPBDDEntry), + ACGHCDLBCGD: bool = false, + GJPKHDHDCDN: ArrayList(GJPKHDHDCDNEntry), + CJAKHEMDBKF: ArrayList(u32), + + pub const _desc_table = .{ + .LAHNKMKFGBC = fd(1, .{ .SubMessage = {} }), + .INJKDMPMAGB = fd(5, .{ .SubMessage = {} }), + .JKCEDLFONKH = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .MPHILJEPBDD = fd(3, .{ .List = .{ .SubMessage = {} } }), + .ACGHCDLBCGD = fd(14, .{ .Varint = .Simple }), + .GJPKHDHDCDN = fd(12, .{ .List = .{ .SubMessage = {} } }), + .CJAKHEMDBKF = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub const MPHILJEPBDDEntry = struct { + key: u32 = 0, + value: ?JBDNIEFPHLE = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const GJPKHDHDCDNEntry = struct { + key: u32 = 0, + value: ?BMLNHLAGLIP = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMJLNMPCJJA = struct { + AFHJGLGLKHD: ?NBGPGDMLKAD = null, + + pub const _desc_table = .{ + .AFHJGLGLKHD = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HKGAAOGNCFN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AOCLGEBPHNJ = struct { + retcode: u32 = 0, + scene: ?SceneInfo = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .scene = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNBIIDMJMJA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGNJKFMJGMP = struct { + scene: ?SceneInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .scene = fd(11, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHFKHFOGLFJ = struct { + LGNHDNODOLM: u32 = 0, + phase: u32 = 0, + LAKPOEKFOFH: u32 = 0, + HKECOMPALIL: bool = false, + LDAMNJPGJOC: bool = false, + BIPEPADLEIA: ArrayList(BattleTarget), + HEMJIDNEAHO: u32 = 0, + OACCGIKCECI: u32 = 0, + CKDHFNAFNBN: u32 = 0, + JFKBGANLNGF: bool = false, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(10, .{ .Varint = .Simple }), + .phase = fd(3, .{ .Varint = .Simple }), + .LAKPOEKFOFH = fd(14, .{ .Varint = .Simple }), + .HKECOMPALIL = fd(2, .{ .Varint = .Simple }), + .LDAMNJPGJOC = fd(1, .{ .Varint = .Simple }), + .BIPEPADLEIA = fd(7, .{ .List = .{ .SubMessage = {} } }), + .HEMJIDNEAHO = fd(9, .{ .Varint = .Simple }), + .OACCGIKCECI = fd(6, .{ .Varint = .Simple }), + .CKDHFNAFNBN = fd(8, .{ .Varint = .Simple }), + .JFKBGANLNGF = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFEPFGCCDJA = struct { + IIKPKOKNIAL: ManagedString = .Empty, + OJEPBCFEFAG: MsgType = @enumFromInt(0), + ENLMBCCJFBG: ?JDKPHOFLFEN = null, + HFCGMKLFDDJ: u32 = 0, + FGDNCHDLNID: ArrayList(u32), + LDKCHACMPJI: ChatType = @enumFromInt(0), + + pub const _desc_table = .{ + .IIKPKOKNIAL = fd(7, .String), + .OJEPBCFEFAG = fd(8, .{ .Varint = .Simple }), + .ENLMBCCJFBG = fd(10, .{ .SubMessage = {} }), + .HFCGMKLFDDJ = fd(12, .{ .Varint = .Simple }), + .FGDNCHDLNID = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .LDKCHACMPJI = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MODDDBGKIKO = struct { + end_time: u64 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .end_time = fd(11, .{ .Varint = .Simple }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IIBLKIBAAFA = struct { + EGFGLOIACGK: ManagedString = .Empty, + HFCGMKLFDDJ: u32 = 0, + FADGPBGDLBG: u64 = 0, + IJIDAJHNCLN: u32 = 0, + ENLMBCCJFBG: ?JDKPHOFLFEN = null, + OJEPBCFEFAG: MsgType = @enumFromInt(0), + + pub const _desc_table = .{ + .EGFGLOIACGK = fd(10, .String), + .HFCGMKLFDDJ = fd(11, .{ .Varint = .Simple }), + .FADGPBGDLBG = fd(13, .{ .Varint = .Simple }), + .IJIDAJHNCLN = fd(5, .{ .Varint = .Simple }), + .ENLMBCCJFBG = fd(8, .{ .SubMessage = {} }), + .OJEPBCFEFAG = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCLGNNHEBJJ = struct { + OJEPBCFEFAG: MsgType = @enumFromInt(0), + ENLMBCCJFBG: ?JDKPHOFLFEN = null, + BIEPMPDIGIA: u32 = 0, + LDKCHACMPJI: ChatType = @enumFromInt(0), + HFCGMKLFDDJ: u32 = 0, + IIKPKOKNIAL: ManagedString = .Empty, + LGFCOHDOIBH: u32 = 0, + + pub const _desc_table = .{ + .OJEPBCFEFAG = fd(11, .{ .Varint = .Simple }), + .ENLMBCCJFBG = fd(14, .{ .SubMessage = {} }), + .BIEPMPDIGIA = fd(4, .{ .Varint = .Simple }), + .LDKCHACMPJI = fd(6, .{ .Varint = .Simple }), + .HFCGMKLFDDJ = fd(8, .{ .Varint = .Simple }), + .IIKPKOKNIAL = fd(10, .String), + .LGFCOHDOIBH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPOKGKEPMID = struct { + LCCIFIEPMLI: ArrayList(u32), + + pub const _desc_table = .{ + .LCCIFIEPMLI = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGFNHLFHNKL = struct { + PAFMFIBJJBA: u32 = 0, + KCEBMAAIMMN: u32 = 0, + + pub const _desc_table = .{ + .PAFMFIBJJBA = fd(5, .{ .Varint = .Simple }), + .KCEBMAAIMMN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLBHIEHEDEN = struct { + retcode: u32 = 0, + PAFMFIBJJBA: u32 = 0, + KCEBMAAIMMN: u32 = 0, + GJOMOCMCNBD: ArrayList(IIBLKIBAAFA), + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .PAFMFIBJJBA = fd(11, .{ .Varint = .Simple }), + .KCEBMAAIMMN = fd(2, .{ .Varint = .Simple }), + .GJOMOCMCNBD = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CCOKGHNEJGC = struct { + FKNBCLBJNGK: i64 = 0, + KCEBMAAIMMN: u32 = 0, + + pub const _desc_table = .{ + .FKNBCLBJNGK = fd(13, .{ .Varint = .Simple }), + .KCEBMAAIMMN = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EKLDLAJLDGA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENBJPNLNLJO = struct { + LEKIHKPBDNF: ArrayList(CCOKGHNEJGC), + retcode: u32 = 0, + + pub const _desc_table = .{ + .LEKIHKPBDNF = fd(15, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFMDLPBOEFA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LAPAAEGECGN = struct { + retcode: u32 = 0, + LANDMJAOEJJ: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .LANDMJAOEJJ = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEBOPGNOFHM = struct { + HFCGMKLFDDJ: u32 = 0, + DIFIMHEPIMF: bool = false, + + pub const _desc_table = .{ + .HFCGMKLFDDJ = fd(7, .{ .Varint = .Simple }), + .DIFIMHEPIMF = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMBKKIGPNPG = struct { + HFCGMKLFDDJ: u32 = 0, + DIFIMHEPIMF: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .HFCGMKLFDDJ = fd(5, .{ .Varint = .Simple }), + .DIFIMHEPIMF = fd(15, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNFFLDALLLG = struct { + JOHFGNBDEIM: ArrayList(u32), + + pub const _desc_table = .{ + .JOHFGNBDEIM = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNPJEPIPEFE = struct { + retcode: u32 = 0, + JOHFGNBDEIM: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .JOHFGNBDEIM = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFAMIINFFKC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJGEPAIJNGM = struct { + retcode: u32 = 0, + LCCIFIEPMLI: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .LCCIFIEPMLI = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const INKGALKABAO = struct { + PLLLDFLFBFA: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .PLLLDFLFBFA = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOJMKKNOKFB = struct { + lineup: ?LineupInfo = null, + scene: ?SceneInfo = null, + + pub const _desc_table = .{ + .lineup = fd(15, .{ .SubMessage = {} }), + .scene = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDANDAJEPHK = struct { + id: u32 = 0, + DDNKEGAPKIA: ArrayList(u32), + + pub const _desc_table = .{ + .id = fd(10, .{ .Varint = .Simple }), + .DDNKEGAPKIA = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPENCNJJCHP = struct { + FFPNALDKGJM: ArrayList(PDANDAJEPHK), + + pub const _desc_table = .{ + .FFPNALDKGJM = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPDJJKDEKCN = struct { + CACKIGMCKFK: u32 = 0, + BGAKMPLHIII: u32 = 0, + KDGGOKGJLMC: u32 = 0, + CLDNFIJILNP: ArrayList(u32), + CHDONICFGKA: u32 = 0, + NJHNLLEOFJL: MDKFCMBNFGK = @enumFromInt(0), + DEGKBGPPNMA: ?FEFBDIHENLC = null, + KGIEPAEIBHK: ?GOOFAJHLCEE = null, + AMDLOMOGEOE: ?ICNMLEMMHKL = null, + FPFEHDIKMFN: u32 = 0, + DPNCGPOLFKH: bool = false, + NHFELECMHIN: i32 = 0, + DCFMPLEEGBL: u32 = 0, + GFAMOOMGEMB: u32 = 0, + BBOOMNACLEC: NAJBNNGJKPA = @enumFromInt(0), + OGIABIHLLCD: u32 = 0, + KMFBBBGKGHC: bool = false, + + pub const _desc_table = .{ + .CACKIGMCKFK = fd(8, .{ .Varint = .Simple }), + .BGAKMPLHIII = fd(13, .{ .Varint = .Simple }), + .KDGGOKGJLMC = fd(11, .{ .Varint = .Simple }), + .CLDNFIJILNP = fd(1633, .{ .PackedList = .{ .Varint = .Simple } }), + .CHDONICFGKA = fd(3, .{ .Varint = .Simple }), + .NJHNLLEOFJL = fd(12, .{ .Varint = .Simple }), + .DEGKBGPPNMA = fd(617, .{ .SubMessage = {} }), + .KGIEPAEIBHK = fd(1741, .{ .SubMessage = {} }), + .AMDLOMOGEOE = fd(263, .{ .SubMessage = {} }), + .FPFEHDIKMFN = fd(10, .{ .Varint = .Simple }), + .DPNCGPOLFKH = fd(15, .{ .Varint = .Simple }), + .NHFELECMHIN = fd(944, .{ .Varint = .Simple }), + .DCFMPLEEGBL = fd(2, .{ .Varint = .Simple }), + .GFAMOOMGEMB = fd(14, .{ .Varint = .Simple }), + .BBOOMNACLEC = fd(9, .{ .Varint = .Simple }), + .OGIABIHLLCD = fd(4, .{ .Varint = .Simple }), + .KMFBBBGKGHC = fd(162, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBDHCNJIMJC = struct { + OHCBBBKBIPJ: u32 = 0, + + pub const _desc_table = .{ + .OHCBBBKBIPJ = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FDEPJELPHOE = struct { + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + DHENOCJFBOH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ILMJIIDHNAB = fd(1, .{ .SubMessage = {} }), + .DHENOCJFBOH = fd(5, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MACDFDGEAGJ = struct { + JLJIKLDHIJE: u32 = 0, + + pub const _desc_table = .{ + .JLJIKLDHIJE = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLMADLFICIC = struct { + JLJIKLDHIJE: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .JLJIKLDHIJE = fd(11, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PANPOIHCIOI = struct { + monster_id: u32 = 0, + FPMINHFKFKF: u32 = 0, + + pub const _desc_table = .{ + .monster_id = fd(15, .{ .Varint = .Simple }), + .FPMINHFKFKF = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJHJKDBEEKE = struct { + ANDDPNOBLJB: ArrayList(PANPOIHCIOI), + OKMLIAHGICG: u32 = 0, + AAFBIGKBCOM: bool = false, + + pub const _desc_table = .{ + .ANDDPNOBLJB = fd(3, .{ .List = .{ .SubMessage = {} } }), + .OKMLIAHGICG = fd(13, .{ .Varint = .Simple }), + .AAFBIGKBCOM = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIKHKDMAGPH = struct { + HOIICKOFOIK: ArrayList(u32), + IMPBNMLGOPF: ArrayList(u32), + + pub const _desc_table = .{ + .HOIICKOFOIK = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .IMPBNMLGOPF = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDGLNDMEMED = struct { + CNMPFAAIGGA: ?NJHJKDBEEKE = null, + OPBEPNFEAKH: ?DIKHKDMAGPH = null, + + pub const _desc_table = .{ + .CNMPFAAIGGA = fd(5, .{ .SubMessage = {} }), + .OPBEPNFEAKH = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJPEFALOGHD = struct { + CNMPFAAIGGA: ?NJHJKDBEEKE = null, + OPBEPNFEAKH: ?DIKHKDMAGPH = null, + APDAFMCMJJE: ?HDGLNDMEMED = null, + + pub const _desc_table = .{ + .CNMPFAAIGGA = fd(7, .{ .SubMessage = {} }), + .OPBEPNFEAKH = fd(8, .{ .SubMessage = {} }), + .APDAFMCMJJE = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MLAIBNAKIJG = struct { + JEIKKNONCDM: u32 = 0, + PIJAIMBBNPG: bool = false, + LOHJBAKJJEM: u32 = 0, + DPBEHOGNBOO: u32 = 0, + JEHEAOINGMP: bool = false, + id: u32 = 0, + PNCAKMFAOHI: NLFCJLEEOLJ = @enumFromInt(0), + GKGOKJJGINE: ?PJPEFALOGHD = null, + BICGKJHDPNJ: u32 = 0, + IHMBEENNCMC: BAKDCEGIGBP = @enumFromInt(0), + GKAPPNGOCNB: ArrayList(u32), + LOPNFDJHCLN: u32 = 0, + + pub const _desc_table = .{ + .JEIKKNONCDM = fd(5, .{ .Varint = .Simple }), + .PIJAIMBBNPG = fd(10, .{ .Varint = .Simple }), + .LOHJBAKJJEM = fd(3, .{ .Varint = .Simple }), + .DPBEHOGNBOO = fd(1, .{ .Varint = .Simple }), + .JEHEAOINGMP = fd(14, .{ .Varint = .Simple }), + .id = fd(6, .{ .Varint = .Simple }), + .PNCAKMFAOHI = fd(9, .{ .Varint = .Simple }), + .GKGOKJJGINE = fd(12, .{ .SubMessage = {} }), + .BICGKJHDPNJ = fd(8, .{ .Varint = .Simple }), + .IHMBEENNCMC = fd(2, .{ .Varint = .Simple }), + .GKAPPNGOCNB = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .LOPNFDJHCLN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOPFOOBHBFJ = struct { + LFGJBNGLBKI: u32 = 0, + AJLKHOKKMAO: ArrayList(MLAIBNAKIJG), + EPOELFJDPNI: u32 = 0, + CNCECHHELJK: u32 = 0, + FGEOEOPLMCP: u32 = 0, + + pub const _desc_table = .{ + .LFGJBNGLBKI = fd(10, .{ .Varint = .Simple }), + .AJLKHOKKMAO = fd(14, .{ .List = .{ .SubMessage = {} } }), + .EPOELFJDPNI = fd(9, .{ .Varint = .Simple }), + .CNCECHHELJK = fd(7, .{ .Varint = .Simple }), + .FGEOEOPLMCP = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODFBDFMEJHN = struct { + LOPNFDJHCLN: u32 = 0, + JLJIKLDHIJE: u32 = 0, + + pub const _desc_table = .{ + .LOPNFDJHCLN = fd(13, .{ .Varint = .Simple }), + .JLJIKLDHIJE = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDIPIHPMEKN = struct { + NGHLOHOEOID: u32 = 0, + FPGMAJOGPGG: ?ICNMLEMMHKL = null, + + pub const _desc_table = .{ + .NGHLOHOEOID = fd(10, .{ .Varint = .Simple }), + .FPGMAJOGPGG = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKMDMKBJGHC = struct { + JACOFFFKKEI: NLFCJLEEOLJ = @enumFromInt(0), + OJNCMJDAABJ: ?JDIPIHPMEKN = null, + MDFENJLDCJP: ArrayList(u32), + JNAOCDNDNBC: ?JOPFOOBHBFJ = null, + NBKJOONBFKK: ArrayList(ODFBDFMEJHN), + JPKLCDAEHJA: u32 = 0, + CMJAMBMODIM: u32 = 0, + + pub const _desc_table = .{ + .JACOFFFKKEI = fd(13, .{ .Varint = .Simple }), + .OJNCMJDAABJ = fd(1, .{ .SubMessage = {} }), + .MDFENJLDCJP = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .JNAOCDNDNBC = fd(2, .{ .SubMessage = {} }), + .NBKJOONBFKK = fd(7, .{ .List = .{ .SubMessage = {} } }), + .JPKLCDAEHJA = fd(12, .{ .Varint = .Simple }), + .CMJAMBMODIM = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONACBNGCGBP = struct { + FMOMABLDNCF: i32 = 0, + KAPEOLCJMMB: u32 = 0, + HCAOIINOLDN: u32 = 0, + ICPIADMKAEM: ArrayList(u32), + id: u32 = 0, + IPCIEPIHPLF: ArrayList(u32), + PLANCGLJEFE: u32 = 0, + CFLDHMBNFEP: ?IKMDMKBJGHC = null, + FKPDBENEJNF: i32 = 0, + + pub const _desc_table = .{ + .FMOMABLDNCF = fd(8, .{ .Varint = .Simple }), + .KAPEOLCJMMB = fd(15, .{ .Varint = .Simple }), + .HCAOIINOLDN = fd(14, .{ .Varint = .Simple }), + .ICPIADMKAEM = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .id = fd(6, .{ .Varint = .Simple }), + .IPCIEPIHPLF = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .PLANCGLJEFE = fd(7, .{ .Varint = .Simple }), + .CFLDHMBNFEP = fd(1, .{ .SubMessage = {} }), + .FKPDBENEJNF = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EPHFGGGDDOL = struct { + OKGJGNDJIDE: u32 = 0, + FBNEHOBFJNP: u32 = 0, + + pub const _desc_table = .{ + .OKGJGNDJIDE = fd(10, .{ .Varint = .Simple }), + .FBNEHOBFJNP = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFODKJEJLNM = struct { + IFIMPEJLPPF: ArrayList(EPHFGGGDDOL), + + pub const _desc_table = .{ + .IFIMPEJLPPF = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEEKEIHDKDF = struct { + PLGGEKOENOI: ?KFODKJEJLNM = null, + FPGMAJOGPGG: ?ICNMLEMMHKL = null, + KNIDGHHDIKJ: i32 = 0, + IGFKGOFCPAO: u32 = 0, + BIHOFLAIKAP: ArrayList(u32), + + pub const _desc_table = .{ + .PLGGEKOENOI = fd(2, .{ .SubMessage = {} }), + .FPGMAJOGPGG = fd(15, .{ .SubMessage = {} }), + .KNIDGHHDIKJ = fd(10, .{ .Varint = .Simple }), + .IGFKGOFCPAO = fd(1, .{ .Varint = .Simple }), + .BIHOFLAIKAP = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FOPHLFHHDJK = struct { + IEDLKIPPLDB: u32 = 0, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .IEDLKIPPLDB = fd(12, .{ .Varint = .Simple }), + .avatar_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PAIPHBHDMGA = struct { + DOCPIMKNJOO: ArrayList(FOPHLFHHDJK), + ABHEGBEHLJK: ?INKGALKABAO = null, + + pub const _desc_table = .{ + .DOCPIMKNJOO = fd(11, .{ .List = .{ .SubMessage = {} } }), + .ABHEGBEHLJK = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOICCEIFBBA = struct { + GJHNPLHBGAE: ArrayList(u32), + KJALGDHJNLN: u32 = 0, + ALNMBFMEIAC: bool = false, + INHOFMDEECK: u32 = 0, + + pub const _desc_table = .{ + .GJHNPLHBGAE = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .KJALGDHJNLN = fd(1, .{ .Varint = .Simple }), + .ALNMBFMEIAC = fd(14, .{ .Varint = .Simple }), + .INHOFMDEECK = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NHHKFCMAEBC = struct { + PEKMEIDBNLH: i32 = 0, + + pub const _desc_table = .{ + .PEKMEIDBNLH = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMOPNGJKOEE = struct { + KLDGPPEPGFA: ArrayList(u32), + + pub const _desc_table = .{ + .KLDGPPEPGFA = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KBAAEPLPBBD = struct { + LDMGIHBCHBL: ?LGPKGFPBGMK = null, + FENFEHFCGPO: ?IMIKGILFCCI = null, + JHIPPDPKJOH: ?NHHKFCMAEBC = null, + NNLELKHHBCL: u32 = 0, + IPGJMDCIIHH: ?ONACBNGCGBP = null, + PNDBNEBJACA: ?KMOPNGJKOEE = null, + NKGKDMFHGFJ: ?JPFECHLHHEN = null, + ODEHLKCFDIJ: ?NEEKEIHDKDF = null, + GKHNCIGJIBE: ?NCLDKJHEPGM = null, + OLIBJIMDGGB: ?IBLHIDENCOG = null, + JGHAOFCGEMP: ?PAIPHBHDMGA = null, + DNNNDJCADJE: ?IKHJMMFFDFD = null, + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + GCBMCEAHIFC: ArrayList(GDEDIPOBJEN), + EHAFGOGAFCD: ?MOICCEIFBBA = null, + + pub const _desc_table = .{ + .LDMGIHBCHBL = fd(6, .{ .SubMessage = {} }), + .FENFEHFCGPO = fd(10, .{ .SubMessage = {} }), + .JHIPPDPKJOH = fd(4, .{ .SubMessage = {} }), + .NNLELKHHBCL = fd(11, .{ .Varint = .Simple }), + .IPGJMDCIIHH = fd(15, .{ .SubMessage = {} }), + .PNDBNEBJACA = fd(1749, .{ .SubMessage = {} }), + .NKGKDMFHGFJ = fd(3, .{ .SubMessage = {} }), + .ODEHLKCFDIJ = fd(12, .{ .SubMessage = {} }), + .GKHNCIGJIBE = fd(14, .{ .SubMessage = {} }), + .OLIBJIMDGGB = fd(5, .{ .SubMessage = {} }), + .JGHAOFCGEMP = fd(8, .{ .SubMessage = {} }), + .DNNNDJCADJE = fd(1, .{ .SubMessage = {} }), + .ILMJIIDHNAB = fd(9, .{ .SubMessage = {} }), + .GCBMCEAHIFC = fd(13, .{ .List = .{ .SubMessage = {} } }), + .EHAFGOGAFCD = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJDKJANHCNO = struct { + ICPIADMKAEM: ArrayList(u32), + GHCJGBFCGHH: ?ABPEIABAKOH = null, + OOJOIDFPMIG: ?LJPHJBEADBB = null, + PLGGEKOENOI: ?KFODKJEJLNM = null, + GKHNCIGJIBE: ?NCLDKJHEPGM = null, + IPCIEPIHPLF: ArrayList(u32), + PNDBNEBJACA: ?MJLHAIFJKEA = null, + + pub const _desc_table = .{ + .ICPIADMKAEM = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .GHCJGBFCGHH = fd(11, .{ .SubMessage = {} }), + .OOJOIDFPMIG = fd(14, .{ .SubMessage = {} }), + .PLGGEKOENOI = fd(7, .{ .SubMessage = {} }), + .GKHNCIGJIBE = fd(12, .{ .SubMessage = {} }), + .IPCIEPIHPLF = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .PNDBNEBJACA = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJCFHJNKEPG = struct { + NNLELKHHBCL: u32 = 0, + GCBMCEAHIFC: ArrayList(GDEDIPOBJEN), + + pub const _desc_table = .{ + .NNLELKHHBCL = fd(7, .{ .Varint = .Simple }), + .GCBMCEAHIFC = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMEKJAINPPG = struct { + PNDBNEBJACA: ?MJLHAIFJKEA = null, + ICPIADMKAEM: ArrayList(u32), + GHCJGBFCGHH: ?ABPEIABAKOH = null, + OOJOIDFPMIG: ?LJPHJBEADBB = null, + PLGGEKOENOI: ?KFODKJEJLNM = null, + IPCIEPIHPLF: ArrayList(u32), + + pub const _desc_table = .{ + .PNDBNEBJACA = fd(8, .{ .SubMessage = {} }), + .ICPIADMKAEM = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .GHCJGBFCGHH = fd(9, .{ .SubMessage = {} }), + .OOJOIDFPMIG = fd(3, .{ .SubMessage = {} }), + .PLGGEKOENOI = fd(1, .{ .SubMessage = {} }), + .IPCIEPIHPLF = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HKBGCJKCNAN = struct { + PMDBOGBOBDD: EMNLDJGMBCA = @enumFromInt(0), + LEBECEFMDJN: u32 = 0, + AKAFAPOJALN: ?LineupInfo = null, + DNNNDJCADJE: ?BBLNDEMIPMI = null, + NNLELKHHBCL: u32 = 0, + HHMFIDKFNNI: ArrayList(u32), + GEGBPPHDHKM: u32 = 0, + CNCAOLEDBDI: u32 = 0, + LABKEECGNIE: u32 = 0, + EPGJCMNBIPJ: ?ItemList = null, + PMKBCMKOGEN: u32 = 0, + FDDOLEGBPHH: u32 = 0, + LDMGIHBCHBL: ?FJBBJBIHOCP = null, + DODPBNFKKEL: u32 = 0, + OLMBPLAIMLP: u32 = 0, + BIOHIBDDDFG: u32 = 0, + CHGPIDCCKEB: bool = false, + NKGKDMFHGFJ: ?JPFECHLHHEN = null, + ILBOMEBLAEH: u32 = 0, + + pub const _desc_table = .{ + .PMDBOGBOBDD = fd(14, .{ .Varint = .Simple }), + .LEBECEFMDJN = fd(1129, .{ .Varint = .Simple }), + .AKAFAPOJALN = fd(10, .{ .SubMessage = {} }), + .DNNNDJCADJE = fd(7, .{ .SubMessage = {} }), + .NNLELKHHBCL = fd(862, .{ .Varint = .Simple }), + .HHMFIDKFNNI = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .GEGBPPHDHKM = fd(1, .{ .Varint = .Simple }), + .CNCAOLEDBDI = fd(1705, .{ .Varint = .Simple }), + .LABKEECGNIE = fd(2, .{ .Varint = .Simple }), + .EPGJCMNBIPJ = fd(3, .{ .SubMessage = {} }), + .PMKBCMKOGEN = fd(11, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(468, .{ .Varint = .Simple }), + .LDMGIHBCHBL = fd(12, .{ .SubMessage = {} }), + .DODPBNFKKEL = fd(6, .{ .Varint = .Simple }), + .OLMBPLAIMLP = fd(15, .{ .Varint = .Simple }), + .BIOHIBDDDFG = fd(912, .{ .Varint = .Simple }), + .CHGPIDCCKEB = fd(4, .{ .Varint = .Simple }), + .NKGKDMFHGFJ = fd(1250, .{ .SubMessage = {} }), + .ILBOMEBLAEH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOHIFMMCCLK = struct { + AJLKHOKKMAO: ArrayList(MLAIBNAKIJG), + GPGLFHPIJJB: u32 = 0, + + pub const _desc_table = .{ + .AJLKHOKKMAO = fd(14, .{ .List = .{ .SubMessage = {} } }), + .GPGLFHPIJJB = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDHNOBDPFED = struct { + IEPPOOJBKHK: u32 = 0, + ILBOMEBLAEH: u32 = 0, + + pub const _desc_table = .{ + .IEPPOOJBKHK = fd(14, .{ .Varint = .Simple }), + .ILBOMEBLAEH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGHOOCIFHCB = struct { + KJALGDHJNLN: u32 = 0, + ONIDGPLKHJD: u32 = 0, + + pub const _desc_table = .{ + .KJALGDHJNLN = fd(2, .{ .Varint = .Simple }), + .ONIDGPLKHJD = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFDHLNBJGLC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LOMPMMFHMAD = struct { + BLJGIINGHIH: ?JJCFHJNKEPG = null, + CLJAGKAHIIC: ?LJDKJANHCNO = null, + GFKIPFIJBGF: ?HKBGCJKCNAN = null, + DINGJPLIJKG: ?NMEKJAINPPG = null, + retcode: u32 = 0, + ILGGJOFHOCN: ?KBAAEPLPBBD = null, + + pub const _desc_table = .{ + .BLJGIINGHIH = fd(8, .{ .SubMessage = {} }), + .CLJAGKAHIIC = fd(12, .{ .SubMessage = {} }), + .GFKIPFIJBGF = fd(11, .{ .SubMessage = {} }), + .DINGJPLIJKG = fd(3, .{ .SubMessage = {} }), + .retcode = fd(6, .{ .Varint = .Simple }), + .ILGGJOFHOCN = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLJEKBBGEEI = struct { + JLJIKLDHIJE: u32 = 0, + PLHIHIJFGLI: u32 = 0, + + pub const _desc_table = .{ + .JLJIKLDHIJE = fd(3, .{ .Varint = .Simple }), + .PLHIHIJFGLI = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIENDEHEGIJ = struct { + retcode: u32 = 0, + GKGOKJJGINE: ?HOJMKKNOKFB = null, + JLJIKLDHIJE: u32 = 0, + BLJGIINGHIH: ?JJCFHJNKEPG = null, + ILGGJOFHOCN: ?KBAAEPLPBBD = null, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .GKGOKJJGINE = fd(4, .{ .SubMessage = {} }), + .JLJIKLDHIJE = fd(11, .{ .Varint = .Simple }), + .BLJGIINGHIH = fd(5, .{ .SubMessage = {} }), + .ILGGJOFHOCN = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHLJOHOMOLK = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIMAMEKJPND = struct { + GKGOKJJGINE: ?HOJMKKNOKFB = null, + retcode: u32 = 0, + ILGGJOFHOCN: ?KBAAEPLPBBD = null, + id: u32 = 0, + BLJGIINGHIH: ?JJCFHJNKEPG = null, + + pub const _desc_table = .{ + .GKGOKJJGINE = fd(15, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + .ILGGJOFHOCN = fd(3, .{ .SubMessage = {} }), + .id = fd(12, .{ .Varint = .Simple }), + .BLJGIINGHIH = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBIBKCICAHH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGGGPDIKJIJ = struct { + ODEHLKCFDIJ: ?NEEKEIHDKDF = null, + DINGJPLIJKG: ?NMEKJAINPPG = null, + GKGOKJJGINE: ?HOJMKKNOKFB = null, + CLJAGKAHIIC: ?LJDKJANHCNO = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ODEHLKCFDIJ = fd(9, .{ .SubMessage = {} }), + .DINGJPLIJKG = fd(12, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(3, .{ .SubMessage = {} }), + .CLJAGKAHIIC = fd(4, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLBOOFJAAOA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEOIMMAKCLJ = struct { + GFKIPFIJBGF: ?HKBGCJKCNAN = null, + GKGOKJJGINE: ?HOJMKKNOKFB = null, + DINGJPLIJKG: ?NMEKJAINPPG = null, + ODEHLKCFDIJ: ?NEEKEIHDKDF = null, + CLJAGKAHIIC: ?LJDKJANHCNO = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GFKIPFIJBGF = fd(5, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(7, .{ .SubMessage = {} }), + .DINGJPLIJKG = fd(9, .{ .SubMessage = {} }), + .ODEHLKCFDIJ = fd(14, .{ .SubMessage = {} }), + .CLJAGKAHIIC = fd(6, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFPFKGCIILE = struct { + base_avatar_id_list: ArrayList(u32), + BDDNDOMIIGA: u32 = 0, + FBNEHOBFJNP: u32 = 0, + HANFDCIPMMD: ArrayList(u32), + FACAIIIJEKI: ArrayList(u32), + id: u32 = 0, + IAHJJAIDIFN: ArrayList(u32), + + pub const _desc_table = .{ + .base_avatar_id_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .BDDNDOMIIGA = fd(3, .{ .Varint = .Simple }), + .FBNEHOBFJNP = fd(13, .{ .Varint = .Simple }), + .HANFDCIPMMD = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .FACAIIIJEKI = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .id = fd(6, .{ .Varint = .Simple }), + .IAHJJAIDIFN = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OICIJEFCPCI = struct { + ILGGJOFHOCN: ?KBAAEPLPBBD = null, + lineup: ?LineupInfo = null, + scene: ?SceneInfo = null, + GKGOKJJGINE: ?HOJMKKNOKFB = null, + JNIPHKAPMDF: ?JOHIFMMCCLK = null, + retcode: u32 = 0, + BLJGIINGHIH: ?JJCFHJNKEPG = null, + + pub const _desc_table = .{ + .ILGGJOFHOCN = fd(10, .{ .SubMessage = {} }), + .lineup = fd(13, .{ .SubMessage = {} }), + .scene = fd(4, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(14, .{ .SubMessage = {} }), + .JNIPHKAPMDF = fd(8, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + .BLJGIINGHIH = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJALPAOFEHA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIHINOHFBGA = struct { + retcode: u32 = 0, + ILGGJOFHOCN: ?KFODKJEJLNM = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .ILGGJOFHOCN = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NECGEMHBNNG = struct { + ILGGJOFHOCN: ?EPHFGGGDDOL = null, + + pub const _desc_table = .{ + .ILGGJOFHOCN = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENFHDLDKIBN = struct { + PLHIHIJFGLI: u32 = 0, + JLJIKLDHIJE: u32 = 0, + + pub const _desc_table = .{ + .PLHIHIJFGLI = fd(5, .{ .Varint = .Simple }), + .JLJIKLDHIJE = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKKOBIKNAAI = struct { + PLHIHIJFGLI: u32 = 0, + retcode: u32 = 0, + EDMAPEJCENL: ?FOKHJCJLCLO = null, + JLJIKLDHIJE: u32 = 0, + + pub const _desc_table = .{ + .PLHIHIJFGLI = fd(1, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + .EDMAPEJCENL = fd(3, .{ .SubMessage = {} }), + .JLJIKLDHIJE = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAMPBLPCHNN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIOOPNPABBA = struct { + ILGGJOFHOCN: ?FPENCNJJCHP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ILGGJOFHOCN = fd(14, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBLNKFDKPLO = struct { + BMHALFGGHAE: u32 = 0, + + pub const _desc_table = .{ + .BMHALFGGHAE = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EJKFBEBOLEK = struct { + BMHALFGGHAE: u32 = 0, + retcode: u32 = 0, + LHCALIBHDFJ: ?PDANDAJEPHK = null, + + pub const _desc_table = .{ + .BMHALFGGHAE = fd(7, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + .LHCALIBHDFJ = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKDMJFPKNHC = struct { + GFKIPFIJBGF: ?HKBGCJKCNAN = null, + PMKBCMKOGEN: u32 = 0, + HCAOIINOLDN: u32 = 0, + HHMFIDKFNNI: ArrayList(u32), + IPGJMDCIIHH: ?ONACBNGCGBP = null, + + pub const _desc_table = .{ + .GFKIPFIJBGF = fd(11, .{ .SubMessage = {} }), + .PMKBCMKOGEN = fd(10, .{ .Varint = .Simple }), + .HCAOIINOLDN = fd(14, .{ .Varint = .Simple }), + .HHMFIDKFNNI = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .IPGJMDCIIHH = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCHHFDLFPGB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNINBKGPBCB = struct { + HKMIHNFPHAI: ?BBGPFIPBDLB = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .HKMIHNFPHAI = fd(4, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONCMGDKIEMK = struct { + IFDKIEDBFAE: u32 = 0, + + pub const _desc_table = .{ + .IFDKIEDBFAE = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIIBKPFKLAG = struct { + HKMIHNFPHAI: ?BBGPFIPBDLB = null, + PABMOLJDJBM: bool = false, + retcode: u32 = 0, + FAGHKLAOKDO: ?JHALLHFNDEH = null, + + pub const _desc_table = .{ + .HKMIHNFPHAI = fd(8, .{ .SubMessage = {} }), + .PABMOLJDJBM = fd(7, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + .FAGHKLAOKDO = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OGANNCLNINN = struct { + base_avatar_id_list: ArrayList(u32), + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .base_avatar_id_list = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .prop_entity_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKBEMEEBADM = struct { + retcode: u32 = 0, + base_avatar_id_list: ArrayList(u32), + JGHAOFCGEMP: ?PAIPHBHDMGA = null, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .base_avatar_id_list = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .JGHAOFCGEMP = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAEGPGBMGFD = struct { + LDOLLOOEIKA: u32 = 0, + base_avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .LDOLLOOEIKA = fd(4, .{ .Varint = .Simple }), + .base_avatar_id_list = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECAGJNFLLHN = struct { + retcode: u32 = 0, + ABHEGBEHLJK: ?INKGALKABAO = null, + base_avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .ABHEGBEHLJK = fd(6, .{ .SubMessage = {} }), + .base_avatar_id_list = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKNDHFFPHBG = struct { + ABHEGBEHLJK: ?INKGALKABAO = null, + + pub const _desc_table = .{ + .ABHEGBEHLJK = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGKLODMDGCL = struct { + OLIBJIMDGGB: ?IBLHIDENCOG = null, + + pub const _desc_table = .{ + .OLIBJIMDGGB = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KEKEIPFDIDO = struct { + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + + pub const _desc_table = .{ + .ILMJIIDHNAB = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOELNIAHIJB = struct { + NLEFHGHGKPE: BAELJKMHLBH = @enumFromInt(0), + KAPEOLCJMMB: NMCODCECJMC = @enumFromInt(0), + + pub const _desc_table = .{ + .NLEFHGHGKPE = fd(7, .{ .Varint = .Simple }), + .KAPEOLCJMMB = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KNDJPIGFFCE = struct { + NEIACCEIMGB: u32 = 0, + MDFENJLDCJP: ArrayList(u32), + + pub const _desc_table = .{ + .NEIACCEIMGB = fd(13, .{ .Varint = .Simple }), + .MDFENJLDCJP = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMMAKKPAECM = struct { + IKFKGAPCNON: ?JOPFOOBHBFJ = null, + + pub const _desc_table = .{ + .IKFKGAPCNON = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGBDPDHMCPD = struct { + FBNEHOBFJNP: u32 = 0, + KNIDGHHDIKJ: i32 = 0, + + pub const _desc_table = .{ + .FBNEHOBFJNP = fd(5, .{ .Varint = .Simple }), + .KNIDGHHDIKJ = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDMONEDEPFH = struct { + ECKLJPNIHFO: i32 = 0, + + pub const _desc_table = .{ + .ECKLJPNIHFO = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNFNHAKHMBN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ChessRogueSkipTeachingLevelScRsp = struct { + skip_reward_list: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .skip_reward_list = fd(15, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJMFCLJNPMH = struct { + ICPIADMKAEM: ArrayList(u32), + + pub const _desc_table = .{ + .ICPIADMKAEM = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOMLNAIIMNF = struct { + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LBHEINNMFFF = struct { + BLJGIINGHIH: ?JJCFHJNKEPG = null, + GKGOKJJGINE: ?HOJMKKNOKFB = null, + JNIPHKAPMDF: ?JOHIFMMCCLK = null, + BHEIMEPJINE: ?KBAAEPLPBBD = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .BLJGIINGHIH = fd(13, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(15, .{ .SubMessage = {} }), + .JNIPHKAPMDF = fd(2, .{ .SubMessage = {} }), + .BHEIMEPJINE = fd(8, .{ .SubMessage = {} }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FADGECCNOFC = struct { + OHCBBBKBIPJ: u32 = 0, + + pub const _desc_table = .{ + .OHCBBBKBIPJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NHHOGMGKAMH = struct { + retcode: u32 = 0, + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .ILMJIIDHNAB = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HECNANPDFKP = struct { + OHCBBBKBIPJ: u32 = 0, + + pub const _desc_table = .{ + .OHCBBBKBIPJ = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCJJHIDAIEA = struct { + retcode: u32 = 0, + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .ILMJIIDHNAB = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LAPPHBEDIIO = struct { + OHCBBBKBIPJ: u32 = 0, + AMIALKIPCNA: u32 = 0, + + pub const _desc_table = .{ + .OHCBBBKBIPJ = fd(15, .{ .Varint = .Simple }), + .AMIALKIPCNA = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPLGBCLAIFN = struct { + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + AMIALKIPCNA: u32 = 0, + ADJBGAIOOBM: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ILMJIIDHNAB = fd(14, .{ .SubMessage = {} }), + .AMIALKIPCNA = fd(4, .{ .Varint = .Simple }), + .ADJBGAIOOBM = fd(1, .{ .Varint = .Simple }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IABLBNOONEE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DDNPBANNFNI = struct { + retcode: u32 = 0, + EABMLEFCADE: ?ItemList = null, + ILMJIIDHNAB: ?CPDJJKDEKCN = null, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .EABMLEFCADE = fd(8, .{ .SubMessage = {} }), + .ILMJIIDHNAB = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KBJBHKLLPGC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEJHKBPEPPH = struct { + CLJAGKAHIIC: ?LJDKJANHCNO = null, + ILGGJOFHOCN: ?KBAAEPLPBBD = null, + retcode: u32 = 0, + DINGJPLIJKG: ?NMEKJAINPPG = null, + IPGJMDCIIHH: ?ONACBNGCGBP = null, + GKGOKJJGINE: ?HOJMKKNOKFB = null, + ODEHLKCFDIJ: ?NEEKEIHDKDF = null, + BLJGIINGHIH: ?JJCFHJNKEPG = null, + GFKIPFIJBGF: ?HKBGCJKCNAN = null, + + pub const _desc_table = .{ + .CLJAGKAHIIC = fd(5, .{ .SubMessage = {} }), + .ILGGJOFHOCN = fd(3, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + .DINGJPLIJKG = fd(6, .{ .SubMessage = {} }), + .IPGJMDCIIHH = fd(4, .{ .SubMessage = {} }), + .GKGOKJJGINE = fd(13, .{ .SubMessage = {} }), + .ODEHLKCFDIJ = fd(15, .{ .SubMessage = {} }), + .BLJGIINGHIH = fd(12, .{ .SubMessage = {} }), + .GFKIPFIJBGF = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLFAJMOIECH = struct { + IPGJMDCIIHH: ?ONACBNGCGBP = null, + + pub const _desc_table = .{ + .IPGJMDCIIHH = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCHKJOLENKH = struct { + ONHIDCFMAHO: u32 = 0, + EABHBAHINGJ: u32 = 0, + JNAOCDNDNBC: ?JOPFOOBHBFJ = null, + + pub const _desc_table = .{ + .ONHIDCFMAHO = fd(8, .{ .Varint = .Simple }), + .EABHBAHINGJ = fd(13, .{ .Varint = .Simple }), + .JNAOCDNDNBC = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJLAHGEBBME = struct { + IOHHPEKLGOM: ILKJJKFPFHC = @enumFromInt(0), + NEIACCEIMGB: u32 = 0, + NLEFHGHGKPE: PCHMJNLPBGF = @enumFromInt(0), + AJLKHOKKMAO: ArrayList(MLAIBNAKIJG), + + pub const _desc_table = .{ + .IOHHPEKLGOM = fd(8, .{ .Varint = .Simple }), + .NEIACCEIMGB = fd(2, .{ .Varint = .Simple }), + .NLEFHGHGKPE = fd(7, .{ .Varint = .Simple }), + .AJLKHOKKMAO = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GPEGFFKKCND = struct { + OKHLKGJLEMK: u32 = 0, + DIFJDGCBOBJ: u32 = 0, + + pub const _desc_table = .{ + .OKHLKGJLEMK = fd(3, .{ .Varint = .Simple }), + .DIFJDGCBOBJ = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDGBPEJNDOK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIOBGJOIMGI = struct { + HCMOKAHEHLE: ArrayList(JGHOOCIFHCB), + GAPFEGNBKIP: ArrayList(HDHNOBDPFED), + retcode: u32 = 0, + + pub const _desc_table = .{ + .HCMOKAHEHLE = fd(7, .{ .List = .{ .SubMessage = {} } }), + .GAPFEGNBKIP = fd(1, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIHIEDFOKPG = struct { + KJALGDHJNLN: u32 = 0, + MNHMNDGAEIE: u32 = 0, + AECBBLMPBBF: u32 = 0, + HKIJGENHOHH: u32 = 0, + + pub const _desc_table = .{ + .KJALGDHJNLN = fd(12, .{ .Varint = .Simple }), + .MNHMNDGAEIE = fd(15, .{ .Varint = .Simple }), + .AECBBLMPBBF = fd(3, .{ .Varint = .Simple }), + .HKIJGENHOHH = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBHIBPFCGAN = struct { + retcode: u32 = 0, + KJALGDHJNLN: u32 = 0, + AECBBLMPBBF: u32 = 0, + MNHMNDGAEIE: u32 = 0, + HKIJGENHOHH: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .KJALGDHJNLN = fd(15, .{ .Varint = .Simple }), + .AECBBLMPBBF = fd(14, .{ .Varint = .Simple }), + .MNHMNDGAEIE = fd(5, .{ .Varint = .Simple }), + .HKIJGENHOHH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHGENBAEKBI = struct { + HKIJGENHOHH: u32 = 0, + AECBBLMPBBF: u32 = 0, + KJALGDHJNLN: u32 = 0, + + pub const _desc_table = .{ + .HKIJGENHOHH = fd(15, .{ .Varint = .Simple }), + .AECBBLMPBBF = fd(7, .{ .Varint = .Simple }), + .KJALGDHJNLN = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAADLJDAJPF = struct { + AECBBLMPBBF: u32 = 0, + retcode: u32 = 0, + KJALGDHJNLN: u32 = 0, + ILBOMEBLAEH: u32 = 0, + HKIJGENHOHH: u32 = 0, + + pub const _desc_table = .{ + .AECBBLMPBBF = fd(12, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + .KJALGDHJNLN = fd(1, .{ .Varint = .Simple }), + .ILBOMEBLAEH = fd(10, .{ .Varint = .Simple }), + .HKIJGENHOHH = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFEDHKCILCP = struct { + FKPDBENEJNF: i32 = 0, + + pub const _desc_table = .{ + .FKPDBENEJNF = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HIBILIGPJKA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLMGOOGFEGA = struct { + GKGOKJJGINE: ?HOJMKKNOKFB = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GKGOKJJGINE = fd(15, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKCDOKGLLNM = struct { + PLADOEMBODM: u32 = 0, + + pub const _desc_table = .{ + .PLADOEMBODM = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICLNBBPBIOG = struct { + PLADOEMBODM: u32 = 0, + retcode: u32 = 0, + FKDHDCGOIMF: ArrayList(FKDHDCGOIMFEntry), + + pub const _desc_table = .{ + .PLADOEMBODM = fd(14, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .FKDHDCGOIMF = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const FKDHDCGOIMFEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMPKLHCNKPG = struct { + IEPPOOJBKHK: u32 = 0, + ILBOMEBLAEH: u32 = 0, + + pub const _desc_table = .{ + .IEPPOOJBKHK = fd(5, .{ .Varint = .Simple }), + .ILBOMEBLAEH = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKLAGHABJGD = struct { + JHIPPDPKJOH: ?NHHKFCMAEBC = null, + + pub const _desc_table = .{ + .JHIPPDPKJOH = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJCHAJDDAPD = struct { + status: PIJHHJMCMGL = @enumFromInt(0), + ILBOMEBLAEH: u32 = 0, + + pub const _desc_table = .{ + .status = fd(4, .{ .Varint = .Simple }), + .ILBOMEBLAEH = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBLGBFEPAGP = struct { + HKIJGENHOHH: u32 = 0, + + pub const _desc_table = .{ + .HKIJGENHOHH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJAFMEBLBIN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABDOGOFMCPE = struct { + HCMOKAHEHLE: ArrayList(OBLGBFEPAGP), + retcode: u32 = 0, + GAPFEGNBKIP: ArrayList(OJCHAJDDAPD), + + pub const _desc_table = .{ + .HCMOKAHEHLE = fd(8, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(3, .{ .Varint = .Simple }), + .GAPFEGNBKIP = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDCJLJJDHAG = struct { + HKIJGENHOHH: u32 = 0, + MNHMNDGAEIE: u32 = 0, + AECBBLMPBBF: u32 = 0, + + pub const _desc_table = .{ + .HKIJGENHOHH = fd(15, .{ .Varint = .Simple }), + .MNHMNDGAEIE = fd(12, .{ .Varint = .Simple }), + .AECBBLMPBBF = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBHOPMOLBHI = struct { + AECBBLMPBBF: u32 = 0, + MNHMNDGAEIE: u32 = 0, + HKIJGENHOHH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .AECBBLMPBBF = fd(12, .{ .Varint = .Simple }), + .MNHMNDGAEIE = fd(9, .{ .Varint = .Simple }), + .HKIJGENHOHH = fd(6, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPHONNDNECH = struct { + HKIJGENHOHH: u32 = 0, + AECBBLMPBBF: u32 = 0, + + pub const _desc_table = .{ + .HKIJGENHOHH = fd(5, .{ .Varint = .Simple }), + .AECBBLMPBBF = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPAKFEMKGHM = struct { + HKIJGENHOHH: u32 = 0, + retcode: u32 = 0, + AECBBLMPBBF: u32 = 0, + + pub const _desc_table = .{ + .HKIJGENHOHH = fd(6, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + .AECBBLMPBBF = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CECPCPACFGL = struct { + HKIJGENHOHH: u32 = 0, + + pub const _desc_table = .{ + .HKIJGENHOHH = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHMGEAEMJHG = struct { + GAPFEGNBKIP: ArrayList(OJCHAJDDAPD), + + pub const _desc_table = .{ + .GAPFEGNBKIP = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPFECHLHHEN = struct { + OIIEELPECGL: u32 = 0, + ILBOMEBLAEH: u32 = 0, + ALNMBFMEIAC: bool = false, + NJJKIOHDOMP: bool = false, + NDJJNLKCNHM: ArrayList(u32), + HKIJGENHOHH: u32 = 0, + PCOMKOLMBBG: ArrayList(u32), + NIMEABELKEH: ArrayList(u32), + + pub const _desc_table = .{ + .OIIEELPECGL = fd(12, .{ .Varint = .Simple }), + .ILBOMEBLAEH = fd(7, .{ .Varint = .Simple }), + .ALNMBFMEIAC = fd(15, .{ .Varint = .Simple }), + .NJJKIOHDOMP = fd(8, .{ .Varint = .Simple }), + .NDJJNLKCNHM = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .HKIJGENHOHH = fd(11, .{ .Varint = .Simple }), + .PCOMKOLMBBG = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .NIMEABELKEH = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGKGKAIFENC = struct { + AMIALKIPCNA: u32 = 0, + FKOACKKCDGE: u32 = 0, + + pub const _desc_table = .{ + .AMIALKIPCNA = fd(6, .{ .Varint = .Simple }), + .FKOACKKCDGE = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEFBDIHENLC = struct { + BDDNDOMIIGA: u32 = 0, + MEHKBOGDGDK: u32 = 0, + HMIDNGCMPCN: ArrayList(GGKGKAIFENC), + KGCPDCEHLEL: u32 = 0, + + pub const _desc_table = .{ + .BDDNDOMIIGA = fd(6, .{ .Varint = .Simple }), + .MEHKBOGDGDK = fd(5, .{ .Varint = .Simple }), + .HMIDNGCMPCN = fd(7, .{ .List = .{ .SubMessage = {} } }), + .KGCPDCEHLEL = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJPHJBEADBB = struct { + MLKDHOECNFL: ArrayList(MLKDHOECNFLEntry), + JLGMMLNNDHH: NEKIHOHLNFP = @enumFromInt(0), + LLENHCMIDMP: ArrayList(u32), + IMDDNCCBPCM: ArrayList(FEFBDIHENLC), + + pub const _desc_table = .{ + .MLKDHOECNFL = fd(9, .{ .List = .{ .SubMessage = {} } }), + .JLGMMLNNDHH = fd(7, .{ .Varint = .Simple }), + .LLENHCMIDMP = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .IMDDNCCBPCM = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const MLKDHOECNFLEntry = struct { + key: u32 = 0, + value: bool = false, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCLDKJHEPGM = struct { + GDNBONNPGCN: u32 = 0, + + pub const _desc_table = .{ + .GDNBONNPGCN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABPEIABAKOH = struct { + GDNBONNPGCN: u32 = 0, + ELMDFFENDNP: ?EAHAIFANGDL = null, + + pub const _desc_table = .{ + .GDNBONNPGCN = fd(10, .{ .Varint = .Simple }), + .ELMDFFENDNP = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJLHAIFJKEA = struct { + CEMKCGMOBPC: ArrayList(u32), + + pub const _desc_table = .{ + .CEMKCGMOBPC = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMNKMEIHJMJ = struct { + OOJOIDFPMIG: ?FEFBDIHENLC = null, + + pub const _desc_table = .{ + .OOJOIDFPMIG = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMFOHLPPJLM = struct { + retcode: u32 = 0, + OOJOIDFPMIG: ?FEFBDIHENLC = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .OOJOIDFPMIG = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHMHCOCPFPA = struct { + DOBPLMPGEND: ?LJPHJBEADBB = null, + + pub const _desc_table = .{ + .DOBPLMPGEND = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEMMIBJDHJA = struct { + FGJBHCMIMEH: u32 = 0, + + pub const _desc_table = .{ + .FGJBHCMIMEH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POCBAOKFHHB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGIODMMJIEP = struct { + GHCJGBFCGHH: ?EAHAIFANGDL = null, + GDNBONNPGCN: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GHCJGBFCGHH = fd(14, .{ .SubMessage = {} }), + .GDNBONNPGCN = fd(9, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLAMOBIBMFH = struct { + KBJMNKPIBJH: u32 = 0, + + pub const _desc_table = .{ + .KBJMNKPIBJH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGKBIHLPPNN = struct { + GHCJGBFCGHH: ?EAHAIFANGDL = null, + retcode: u32 = 0, + GDNBONNPGCN: u32 = 0, + + pub const _desc_table = .{ + .GHCJGBFCGHH = fd(10, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + .GDNBONNPGCN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHIDDMHDCLP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CONGMIHEFBN = struct { + GPPDNODOEBH: u32 = 0, + LDDHLKAPJAD: ArrayList(u32), + + pub const _desc_table = .{ + .GPPDNODOEBH = fd(13, .{ .Varint = .Simple }), + .LDDHLKAPJAD = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMIPDIHNILF = struct { + progress: u32 = 0, + EGHEJGABIBP: ArrayList(CONGMIHEFBN), + retcode: u32 = 0, + NFPGLKCBKIN: ArrayList(u32), + HBEBAPHDCMC: u32 = 0, + HAIBFAKMDAM: u32 = 0, + + pub const _desc_table = .{ + .progress = fd(15, .{ .Varint = .Simple }), + .EGHEJGABIBP = fd(1, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(2, .{ .Varint = .Simple }), + .NFPGLKCBKIN = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .HBEBAPHDCMC = fd(12, .{ .Varint = .Simple }), + .HAIBFAKMDAM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDHBHJBNDMA = struct { + KBJMNKPIBJH: u32 = 0, + + pub const _desc_table = .{ + .KBJMNKPIBJH = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOCOEPPAEHL = struct { + KBJMNKPIBJH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .KBJMNKPIBJH = fd(2, .{ .Varint = .Simple }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOPDKFEIIKH = struct { + IDDHIBDFPII: ArrayList(u32), + GPPDNODOEBH: u32 = 0, + + pub const _desc_table = .{ + .IDDHIBDFPII = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .GPPDNODOEBH = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const INHPJAPCEBC = struct { + retcode: u32 = 0, + GPPDNODOEBH: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HMCPOFDFLCL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKJLICDOOND = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOGGHNBEBMG = struct { + CLMMOJJAJLK: u32 = 0, + DDNFPMCPAIE: u32 = 0, + PNMDKPCBPKB: ArrayList(u32), + + pub const _desc_table = .{ + .CLMMOJJAJLK = fd(9, .{ .Varint = .Simple }), + .DDNFPMCPAIE = fd(8, .{ .Varint = .Simple }), + .PNMDKPCBPKB = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCBGDKFABKE = struct { + PAKGECMHCIG: ArrayList(IOGGHNBEBMG), + PNMDKPCBPKB: ArrayList(u32), + + pub const _desc_table = .{ + .PAKGECMHCIG = fd(5, .{ .List = .{ .SubMessage = {} } }), + .PNMDKPCBPKB = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONDNCDGJABI = struct { + IFDFHMLJLKK: ?PCBGDKFABKE = null, + + pub const _desc_table = .{ + .IFDFHMLJLKK = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONAKBKCHNFK = struct { + IFDFHMLJLKK: ?PCBGDKFABKE = null, + + pub const _desc_table = .{ + .IFDFHMLJLKK = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIMAHOEJEKN = struct { + IFDFHMLJLKK: ?PCBGDKFABKE = null, + + pub const _desc_table = .{ + .IFDFHMLJLKK = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOPCPNPJCJM = struct { + IFDFHMLJLKK: ?PCBGDKFABKE = null, + EBKIJOGNBMH: u32 = 0, + LGLBPKOCIFK: u32 = 0, + + pub const _desc_table = .{ + .IFDFHMLJLKK = fd(2, .{ .SubMessage = {} }), + .EBKIJOGNBMH = fd(8, .{ .Varint = .Simple }), + .LGLBPKOCIFK = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGMKAOBPJIB = struct { + IFDFHMLJLKK: ?PCBGDKFABKE = null, + + pub const _desc_table = .{ + .IFDFHMLJLKK = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBBLICFMJAO = struct { + AKHPCILCDNN: bool = false, + + pub const _desc_table = .{ + .AKHPCILCDNN = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MANNPANJCLL = struct { + BDDHIMGOGLC: u32 = 0, + JAEAHBGOMJG: ?AKJLICDOOND = null, + ELIFOGEMLDE: ?ONDNCDGJABI = null, + IDEGMFPEMLN: ?ONAKBKCHNFK = null, + CNDNDNNKLAB: ?OIMAHOEJEKN = null, + LLNONJCICAA: ?MOPCPNPJCJM = null, + GNBKIDONJPH: ?GGMKAOBPJIB = null, + BHJMMAGEFIJ: ?JBBLICFMJAO = null, + FIIHOANMOKE: bool = false, + + pub const _desc_table = .{ + .BDDHIMGOGLC = fd(12, .{ .Varint = .Simple }), + .JAEAHBGOMJG = fd(1, .{ .SubMessage = {} }), + .ELIFOGEMLDE = fd(3, .{ .SubMessage = {} }), + .IDEGMFPEMLN = fd(13, .{ .SubMessage = {} }), + .CNDNDNNKLAB = fd(10, .{ .SubMessage = {} }), + .LLNONJCICAA = fd(5, .{ .SubMessage = {} }), + .GNBKIDONJPH = fd(11, .{ .SubMessage = {} }), + .BHJMMAGEFIJ = fd(2, .{ .SubMessage = {} }), + .FIIHOANMOKE = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFJBDNNGECB = struct { + LPGNMBCENIC: i32 = 0, + LEFOJPHLFLM: i32 = 0, + CGFPBJEHKAC: i32 = 0, + + pub const _desc_table = .{ + .LPGNMBCENIC = fd(13, .{ .Varint = .Simple }), + .LEFOJPHLFLM = fd(9, .{ .Varint = .Simple }), + .CGFPBJEHKAC = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOGHGBPNLLI = struct { + CAGLENMIPKI: u32 = 0, + unique_id: u64 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .CAGLENMIPKI = fd(13, .{ .Varint = .Simple }), + .unique_id = fd(1, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKIPPPBNMLP = struct { + buff_list: ArrayList(JOGHGBPNLLI), + + pub const _desc_table = .{ + .buff_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GPCCKDMCMDA = struct { + MDBFIEDBPMO: u32 = 0, + GPPDNODOEBH: u32 = 0, + PGBMJLNICPH: u32 = 0, + DNNNDJCADJE: ?PKIPPPBNMLP = null, + KFKBNMFAJKJ: ArrayList(u32), + CHDEKEMNIEA: u32 = 0, + GJAFBHKJIOK: ?MANNPANJCLL = null, + IIHCNNGOLBE: u32 = 0, + BJDGPNJCAJC: ManagedString = .Empty, + JEGHBJMOELL: u32 = 0, + JBBDIEMBGMG: ?GFJBDNNGECB = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MDBFIEDBPMO = fd(1, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(14, .{ .Varint = .Simple }), + .PGBMJLNICPH = fd(11, .{ .Varint = .Simple }), + .DNNNDJCADJE = fd(13, .{ .SubMessage = {} }), + .KFKBNMFAJKJ = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .CHDEKEMNIEA = fd(9, .{ .Varint = .Simple }), + .GJAFBHKJIOK = fd(6, .{ .SubMessage = {} }), + .IIHCNNGOLBE = fd(5, .{ .Varint = .Simple }), + .BJDGPNJCAJC = fd(10, .String), + .JEGHBJMOELL = fd(12, .{ .Varint = .Simple }), + .JBBDIEMBGMG = fd(2, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJGKMBMBACG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHPLBDDEFOP = struct { + IFDFHMLJLKK: ?PCBGDKFABKE = null, + + pub const _desc_table = .{ + .IFDFHMLJLKK = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOAGBFALHED = struct { + LDAMNJPGJOC: bool = false, + EDHHCDNKCGN: u32 = 0, + + pub const _desc_table = .{ + .LDAMNJPGJOC = fd(15, .{ .Varint = .Simple }), + .EDHHCDNKCGN = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCPIGKEAEDD = struct { + avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .avatar_id_list = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MBKIJKIOAMN = struct { + LGLBPKOCIFK: u32 = 0, + COHKFCOADJL: bool = false, + + pub const _desc_table = .{ + .LGLBPKOCIFK = fd(9, .{ .Varint = .Simple }), + .COHKFCOADJL = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFFIHDLGLCE = struct { + EDHHCDNKCGN: u32 = 0, + LDAMNJPGJOC: bool = false, + + pub const _desc_table = .{ + .EDHHCDNKCGN = fd(14, .{ .Varint = .Simple }), + .LDAMNJPGJOC = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FDEGHDICIEB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGDHJIKBFAP = struct { + BDDHIMGOGLC: u32 = 0, + GPPDNODOEBH: u32 = 0, + KEFEOEFJGHD: ?DJGKMBMBACG = null, + IDFFBBHHJHA: ?KHPLBDDEFOP = null, + BCBJOPNCGLB: ?EOAGBFALHED = null, + CAHPEMBLLIE: ?JCPIGKEAEDD = null, + AHNMGIJBJGB: ?MBKIJKIOAMN = null, + GOKOGEIPALK: ?GFFIHDLGLCE = null, + DIDLHMHIJOA: ?FDEGHDICIEB = null, + PGBMJLNICPH: u32 = 0, + + pub const _desc_table = .{ + .BDDHIMGOGLC = fd(5, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(15, .{ .Varint = .Simple }), + .KEFEOEFJGHD = fd(2, .{ .SubMessage = {} }), + .IDFFBBHHJHA = fd(1, .{ .SubMessage = {} }), + .BCBJOPNCGLB = fd(12, .{ .SubMessage = {} }), + .CAHPEMBLLIE = fd(4, .{ .SubMessage = {} }), + .AHNMGIJBJGB = fd(6, .{ .SubMessage = {} }), + .GOKOGEIPALK = fd(13, .{ .SubMessage = {} }), + .DIDLHMHIJOA = fd(11, .{ .SubMessage = {} }), + .PGBMJLNICPH = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MHKEOFMDGLE = struct { + ADKJIIANOOM: ?ItemList = null, + CHDEKEMNIEA: u32 = 0, + progress: u32 = 0, + IIHCNNGOLBE: u32 = 0, + HOLGNJJBLNM: bool = false, + GPPDNODOEBH: u32 = 0, + AHNJDLJONFO: bool = false, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(8, .{ .SubMessage = {} }), + .CHDEKEMNIEA = fd(5, .{ .Varint = .Simple }), + .progress = fd(3, .{ .Varint = .Simple }), + .IIHCNNGOLBE = fd(2, .{ .Varint = .Simple }), + .HOLGNJJBLNM = fd(9, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(12, .{ .Varint = .Simple }), + .AHNJDLJONFO = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AIKFIBAJHID = struct { + retcode: u32 = 0, + CALNDLDIAOP: PBLABLACIPO = @enumFromInt(0), + BFAJJLLGCEE: u32 = 0, + EFHFCMKAKAA: u32 = 0, + battle_info: ?SceneBattleInfo = null, + BDDHIMGOGLC: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .CALNDLDIAOP = fd(4, .{ .Varint = .Simple }), + .BFAJJLLGCEE = fd(11, .{ .Varint = .Simple }), + .EFHFCMKAKAA = fd(5, .{ .Varint = .Simple }), + .battle_info = fd(1, .{ .SubMessage = {} }), + .BDDHIMGOGLC = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJADDPFKHCH = struct { + GPPDNODOEBH: u32 = 0, + CKGIAEIPIKI: bool = false, + + pub const _desc_table = .{ + .GPPDNODOEBH = fd(7, .{ .Varint = .Simple }), + .CKGIAEIPIKI = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLDIFCFKFPK = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BONJJOPPGKL = struct { + BDDHIMGOGLC: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .BDDHIMGOGLC = fd(7, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BPEPIBOEMJP = struct { + unique_id: u64 = 0, + GPPDNODOEBH: u32 = 0, + BDDHIMGOGLC: u32 = 0, + + pub const _desc_table = .{ + .unique_id = fd(2, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(8, .{ .Varint = .Simple }), + .BDDHIMGOGLC = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOIBCFFHLAC = struct { + DNNNDJCADJE: ?PKIPPPBNMLP = null, + GPPDNODOEBH: u32 = 0, + retcode: u32 = 0, + BDDHIMGOGLC: u32 = 0, + IFDFHMLJLKK: ?PCBGDKFABKE = null, + JBBDIEMBGMG: ?GFJBDNNGECB = null, + + pub const _desc_table = .{ + .DNNNDJCADJE = fd(11, .{ .SubMessage = {} }), + .GPPDNODOEBH = fd(12, .{ .Varint = .Simple }), + .retcode = fd(9, .{ .Varint = .Simple }), + .BDDHIMGOGLC = fd(13, .{ .Varint = .Simple }), + .IFDFHMLJLKK = fd(660, .{ .SubMessage = {} }), + .JBBDIEMBGMG = fd(1126, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCMDLBKECCB = struct { + IMIIPMGOHBP: ?MHKEOFMDGLE = null, + + pub const _desc_table = .{ + .IMIIPMGOHBP = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Item = struct { + item_id: u32 = 0, + promotion: u32 = 0, + MainAffixId: u32 = 0, + rank: u32 = 0, + level: u32 = 0, + num: u32 = 0, + unique_id: u32 = 0, + + pub const _desc_table = .{ + .item_id = fd(6, .{ .Varint = .Simple }), + .promotion = fd(1, .{ .Varint = .Simple }), + .MainAffixId = fd(8, .{ .Varint = .Simple }), + .rank = fd(11, .{ .Varint = .Simple }), + .level = fd(5, .{ .Varint = .Simple }), + .num = fd(4, .{ .Varint = .Simple }), + .unique_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ItemList = struct { + item_list: ArrayList(Item), + + pub const _desc_table = .{ + .item_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PileItem = struct { + item_num: u32 = 0, + item_id: u32 = 0, + + pub const _desc_table = .{ + .item_num = fd(8, .{ .Varint = .Simple }), + .item_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ItemCost = struct { + pile_item: ?PileItem = null, + equipment_unique_id: u32 = 0, + relic_unique_id: u32 = 0, + + pub const _desc_table = .{ + .pile_item = fd(4, .{ .SubMessage = {} }), + .equipment_unique_id = fd(8, .{ .Varint = .Simple }), + .relic_unique_id = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEHCKCFABKB = struct { + LHFFLOKIELE: ArrayList(ItemCost), + + pub const _desc_table = .{ + .LHFFLOKIELE = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LIOFNFBHFBO = struct { + DJOAJNAHOKB: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .DJOAJNAHOKB = fd(2, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDJJFDLDEHG = struct { + level: u32 = 0, + rank: u32 = 0, + APAMKMIGAOP: u32 = 0, + exp: u32 = 0, + promotion: u32 = 0, + + pub const _desc_table = .{ + .level = fd(14, .{ .Varint = .Simple }), + .rank = fd(11, .{ .Varint = .Simple }), + .APAMKMIGAOP = fd(12, .{ .Varint = .Simple }), + .exp = fd(7, .{ .Varint = .Simple }), + .promotion = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJNADHPLIPO = struct { + APAMKMIGAOP: u32 = 0, + level: u32 = 0, + main_affix_id: u32 = 0, + sub_affix_list: ArrayList(RelicAffix), + exp: u32 = 0, + + pub const _desc_table = .{ + .APAMKMIGAOP = fd(13, .{ .Varint = .Simple }), + .level = fd(11, .{ .Varint = .Simple }), + .main_affix_id = fd(4, .{ .Varint = .Simple }), + .sub_affix_list = fd(8, .{ .List = .{ .SubMessage = {} } }), + .exp = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPJPPKICHIG = struct { + GMBOBJNAHAF: ?LIOFNFBHFBO = null, + EIPOLDPOAOH: ?HDJJFDLDEHG = null, + BFEEEEKOHJN: ?LJNADHPLIPO = null, + + pub const _desc_table = .{ + .GMBOBJNAHAF = fd(5, .{ .SubMessage = {} }), + .EIPOLDPOAOH = fd(9, .{ .SubMessage = {} }), + .BFEEEEKOHJN = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MLPPNJOPPML = struct { + LHFFLOKIELE: ArrayList(MPJPPKICHIG), + + pub const _desc_table = .{ + .LHFFLOKIELE = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Vector = struct { + x: i32 = 0, + y: i32 = 0, + z: i32 = 0, + + pub const _desc_table = .{ + .x = fd(6, .{ .Varint = .ZigZagOptimized }), + .y = fd(2, .{ .Varint = .ZigZagOptimized }), + .z = fd(15, .{ .Varint = .ZigZagOptimized }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MotionInfo = struct { + pos: ?Vector = null, + rot: ?Vector = null, + + pub const _desc_table = .{ + .pos = fd(5, .{ .SubMessage = {} }), + .rot = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Quaternion = struct { + z: f32 = 0, + y: f32 = 0, + x: f32 = 0, + PEBAFLDDHOK: f32 = 0, + + pub const _desc_table = .{ + .z = fd(15, .{ .FixedInt = .I32 }), + .y = fd(13, .{ .FixedInt = .I32 }), + .x = fd(14, .{ .FixedInt = .I32 }), + .PEBAFLDDHOK = fd(3, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneMonsterWaveParam = struct { + NPKCKJBFEGJ: u32 = 0, + level: u32 = 0, + OPIPGNHDDHO: u32 = 0, + JMMIOGBJHPA: u32 = 0, + + pub const _desc_table = .{ + .NPKCKJBFEGJ = fd(11, .{ .Varint = .Simple }), + .level = fd(4, .{ .Varint = .Simple }), + .OPIPGNHDDHO = fd(1, .{ .Varint = .Simple }), + .JMMIOGBJHPA = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneMonsterInfo = struct { + monster_id: u32 = 0, + max_hp: u32 = 0, + cur_hp: u32 = 0, + + pub const _desc_table = .{ + .monster_id = fd(10, .{ .Varint = .Simple }), + .max_hp = fd(14, .{ .Varint = .Simple }), + .cur_hp = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneMonsterWave = struct { + drop_list: ArrayList(ItemList), + EGPMAHLHJDK: u32 = 0, + GJJAJHKFJHH: u32 = 0, + monster_list: ArrayList(SceneMonsterInfo), + monster_wave_param: ?SceneMonsterWaveParam = null, + + pub const _desc_table = .{ + .drop_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .EGPMAHLHJDK = fd(9, .{ .Varint = .Simple }), + .GJJAJHKFJHH = fd(8, .{ .Varint = .Simple }), + .monster_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + .monster_wave_param = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneBattleInfo = struct { + logic_random_seed: u32 = 0, + battle_avatar_list: ArrayList(BattleAvatar), + MKMGHEFLFDC: ArrayList(FOOFENJCLPI), + buff_list: ArrayList(BattleBuff), + HEAMIJGFDMO: ?EvolveBuildBattleInfo = null, + stage_id: u32 = 0, + FNLHAHFIGNC: ?OFHNBLOGEME = null, + HKOOBMMLGME: ?AELAFNKGADP = null, + BLMFHOEAGIC: ArrayList(BLMFHOEAGICEntry), + MOJLNCNDIOB: bool = false, + HOFFCBLNFNG: u32 = 0, + monster_wave_list: ArrayList(SceneMonsterWave), + world_level: u32 = 0, + BOJHPNCAKOP: u32 = 0, + battle_id: u32 = 0, + + pub const _desc_table = .{ + .logic_random_seed = fd(12, .{ .Varint = .Simple }), + .battle_avatar_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + .MKMGHEFLFDC = fd(1965, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .HEAMIJGFDMO = fd(763, .{ .SubMessage = {} }), + .stage_id = fd(4, .{ .Varint = .Simple }), + .FNLHAHFIGNC = fd(854, .{ .SubMessage = {} }), + .HKOOBMMLGME = fd(63, .{ .SubMessage = {} }), + .BLMFHOEAGIC = fd(149, .{ .List = .{ .SubMessage = {} } }), + .MOJLNCNDIOB = fd(8, .{ .Varint = .Simple }), + .HOFFCBLNFNG = fd(2, .{ .Varint = .Simple }), + .monster_wave_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .world_level = fd(6, .{ .Varint = .Simple }), + .BOJHPNCAKOP = fd(11, .{ .Varint = .Simple }), + .battle_id = fd(14, .{ .Varint = .Simple }), + }; + + pub const BLMFHOEAGICEntry = struct { + key: u32 = 0, + value: ?EOLPBMCFJDL = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFOBLINGFBL = struct { + battle_avatar_list: ArrayList(NFHFIPIOOCB), + monster_wave_list: ArrayList(SceneMonsterWave), + MOJLNCNDIOB: bool = false, + battle_id: u32 = 0, + buff_list: ArrayList(BattleBuff), + logic_random_seed: u32 = 0, + stage_id: u32 = 0, + + pub const _desc_table = .{ + .battle_avatar_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + .monster_wave_list = fd(6, .{ .List = .{ .SubMessage = {} } }), + .MOJLNCNDIOB = fd(5, .{ .Varint = .Simple }), + .battle_id = fd(3, .{ .Varint = .Simple }), + .buff_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + .logic_random_seed = fd(13, .{ .Varint = .Simple }), + .stage_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MBPEFDFDAHO = struct { + avatar_type: AvatarType = @enumFromInt(0), + IJEHMBPEHCM: u32 = 0, + id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(8, .{ .Varint = .Simple }), + .IJEHMBPEHCM = fd(3, .{ .Varint = .Simple }), + .id = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJIECODPGHD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const COKFGKFKELO = struct { + retcode: u32 = 0, + data: ?CHAAMEOKIFJ = null, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .data = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIEDMJCNIKO = struct { + GMIGBLFHHAO: u32 = 0, + status: KLKCMAPNOGA = @enumFromInt(0), + + pub const _desc_table = .{ + .GMIGBLFHHAO = fd(8, .{ .Varint = .Simple }), + .status = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHAAMEOKIFJ = struct { + KNAFCPFCKCJ: ArrayList(FIEDMJCNIKO), + FNMHGEAFLMN: u32 = 0, + + pub const _desc_table = .{ + .KNAFCPFCKCJ = fd(13, .{ .List = .{ .SubMessage = {} } }), + .FNMHGEAFLMN = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCGIEPFFKEG = struct { + data: ?CHAAMEOKIFJ = null, + + pub const _desc_table = .{ + .data = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNKBBCLBNDM = struct { + GMIGBLFHHAO: u32 = 0, + + pub const _desc_table = .{ + .GMIGBLFHHAO = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIBNAGOFKPL = struct { + GMIGBLFHHAO: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GMIGBLFHHAO = fd(7, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALCLJMIMKHE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HABPAAKLOAJ = struct { + OAOPFAGJEGH: u32 = 0, + world_level: u32 = 0, + level: u32 = 0, + LFMIKAPJODF: bool = false, + + pub const _desc_table = .{ + .OAOPFAGJEGH = fd(10, .{ .Varint = .Simple }), + .world_level = fd(11, .{ .Varint = .Simple }), + .level = fd(4, .{ .Varint = .Simple }), + .LFMIKAPJODF = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHOLGAMLJNH = struct { + level: u32 = 0, + + pub const _desc_table = .{ + .level = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BIGKHACIFCA = struct { + retcode: u32 = 0, + level: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .level = fd(7, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MHNECFBFILM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDPCCNEAJJE = struct { + retcode: u32 = 0, + HCKIEHENPNI: ArrayList(u32), + OAOPFAGJEGH: u32 = 0, + DGKPBGMLBBF: ArrayList(HABPAAKLOAJ), + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .HCKIEHENPNI = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .OAOPFAGJEGH = fd(4, .{ .Varint = .Simple }), + .DGKPBGMLBBF = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHAJNAAJFJE = struct { + DGKPBGMLBBF: ArrayList(HABPAAKLOAJ), + HCKIEHENPNI: ArrayList(u32), + OAOPFAGJEGH: u32 = 0, + + pub const _desc_table = .{ + .DGKPBGMLBBF = fd(11, .{ .List = .{ .SubMessage = {} } }), + .HCKIEHENPNI = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .OAOPFAGJEGH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJJBDKJLJBG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BPHDOMLPLFG = struct { + ADKJIIANOOM: ?ItemList = null, + KMHLLGLJNMN: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(1, .{ .SubMessage = {} }), + .KMHLLGLJNMN = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DrinkMakerGuest = struct { + faith: u32 = 0, + guest_id: u32 = 0, + unlocked_favor_tag_list: ArrayList(u32), + + pub const _desc_table = .{ + .faith = fd(12, .{ .Varint = .Simple }), + .guest_id = fd(5, .{ .Varint = .Simple }), + .unlocked_favor_tag_list = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EICPBAEMNEC = struct { + NKONGJOPFIC: ArrayList(u32), + FEMGGGBCCBA: u32 = 0, + GALLIGDMODO: u32 = 0, + OCJJEKEGOAE: u32 = 0, + NEOKIKEGLPF: u32 = 0, + + pub const _desc_table = .{ + .NKONGJOPFIC = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .FEMGGGBCCBA = fd(13, .{ .Varint = .Simple }), + .GALLIGDMODO = fd(4, .{ .Varint = .Simple }), + .OCJJEKEGOAE = fd(7, .{ .Varint = .Simple }), + .NEOKIKEGLPF = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAFJBGEENMC = struct { + PABMOLJDJBM: bool = false, + FCLAFDMNGHB: u32 = 0, + + pub const _desc_table = .{ + .PABMOLJDJBM = fd(5, .{ .Varint = .Simple }), + .FCLAFDMNGHB = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const COIGLOIKHCJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHDCBOEBHEP = struct { + exp: u32 = 0, + EDBBPELBEAM: u32 = 0, + JNAPLPKLJEI: ?EICPBAEMNEC = null, + ACIGPIMKECH: ArrayList(u32), + retcode: u32 = 0, + guest_list: ArrayList(DrinkMakerGuest), + IJFCPIKDAEK: u32 = 0, + OMNPCIOLFBP: u32 = 0, + ONMCCOPHDEM: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .exp = fd(14, .{ .Varint = .Simple }), + .EDBBPELBEAM = fd(4, .{ .Varint = .Simple }), + .JNAPLPKLJEI = fd(2, .{ .SubMessage = {} }), + .ACIGPIMKECH = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(1, .{ .Varint = .Simple }), + .guest_list = fd(8, .{ .List = .{ .SubMessage = {} } }), + .IJFCPIKDAEK = fd(13, .{ .Varint = .Simple }), + .OMNPCIOLFBP = fd(3, .{ .Varint = .Simple }), + .ONMCCOPHDEM = fd(11, .{ .Varint = .Simple }), + .level = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICIHJGBIPPC = struct { + ONMCCOPHDEM: u32 = 0, + LIKBNKOPFIF: ?EICPBAEMNEC = null, + + pub const _desc_table = .{ + .ONMCCOPHDEM = fd(13, .{ .Varint = .Simple }), + .LIKBNKOPFIF = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MakeDrinkScRsp = struct { + retcode: u32 = 0, + is_succ: bool = false, + next_chat_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .is_succ = fd(13, .{ .Varint = .Simple }), + .next_chat_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EndDrinkMakerSequenceCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EndDrinkMakerSequenceScRsp = struct { + tips: u32 = 0, + retcode: u32 = 0, + RequestList: ArrayList(KAFJBGEENMC), + next_sequence_id: u32 = 0, + exp: u32 = 0, + level: u32 = 0, + guest: ?DrinkMakerGuest = null, + reward: ?ItemList = null, + + pub const _desc_table = .{ + .tips = fd(2, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + .RequestList = fd(12, .{ .List = .{ .SubMessage = {} } }), + .next_sequence_id = fd(10, .{ .Varint = .Simple }), + .exp = fd(9, .{ .Varint = .Simple }), + .level = fd(11, .{ .Varint = .Simple }), + .guest = fd(5, .{ .SubMessage = {} }), + .reward = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MakeMissionDrinkCsReq = struct { + FCLAFDMNGHB: u32 = 0, + HAPEGHIPNGA: bool = false, + LIKBNKOPFIF: ?EICPBAEMNEC = null, + + pub const _desc_table = .{ + .FCLAFDMNGHB = fd(3, .{ .Varint = .Simple }), + .HAPEGHIPNGA = fd(2, .{ .Varint = .Simple }), + .LIKBNKOPFIF = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MakeMissionDrinkScRsp = struct { + is_succ: bool = false, + retcode: u32 = 0, + is_save: bool = false, + CustomDrink: ?EICPBAEMNEC = null, + + pub const _desc_table = .{ + .is_succ = fd(10, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + .is_save = fd(12, .{ .Varint = .Simple }), + .CustomDrink = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNHIEKKNKIP = struct { + CEOMHPCMCEJ: u32 = 0, + + pub const _desc_table = .{ + .CEOMHPCMCEJ = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNJJGMAJKCH = struct { + LGNHDNODOLM: u32 = 0, + LIKBNKOPFIF: ?EICPBAEMNEC = null, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(11, .{ .Varint = .Simple }), + .LIKBNKOPFIF = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOCFPHMAOEF = struct { + LGNHDNODOLM: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + PABMOLJDJBM: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(9, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(1, .{ .SubMessage = {} }), + .PABMOLJDJBM = fd(3, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBIJMGLJOPO = struct { + OMNPCIOLFBP: u32 = 0, + + pub const _desc_table = .{ + .OMNPCIOLFBP = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EvolveBuildAvatar = struct { + damage: f64 = 0, + avatar_type: AvatarType = @enumFromInt(0), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .damage = fd(1, .{ .FixedInt = .I64 }), + .avatar_type = fd(11, .{ .Varint = .Simple }), + .avatar_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EvolveBuildLevelInfo = struct { + battle_info: ?EvolveBuildBattleInfo = null, + cur_game_exp: u32 = 0, + battle_target_list: ArrayList(BattleTarget), + round_cnt: u32 = 0, + period_id_list: ArrayList(u32), + avatar_list: ArrayList(EvolveBuildAvatar), + + pub const _desc_table = .{ + .battle_info = fd(9, .{ .SubMessage = {} }), + .cur_game_exp = fd(7, .{ .Varint = .Simple }), + .battle_target_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .round_cnt = fd(10, .{ .Varint = .Simple }), + .period_id_list = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHEINNKFDJN = struct { + LAAFPDHGMBG: u32 = 0, + KFGNAKLPGDN: u32 = 0, + FOGBECBDFDM: u32 = 0, + + pub const _desc_table = .{ + .LAAFPDHGMBG = fd(1, .{ .Varint = .Simple }), + .KFGNAKLPGDN = fd(14, .{ .Varint = .Simple }), + .FOGBECBDFDM = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNKBFNAAEED = struct { + level: u32 = 0, + DAACAHJNOCF: u32 = 0, + + pub const _desc_table = .{ + .level = fd(4, .{ .Varint = .Simple }), + .DAACAHJNOCF = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEALLANNPBB = struct { + LAAFPDHGMBG: u32 = 0, + LCAKPPPACKG: ArrayList(u32), + DDNHFBNFEHB: bool = false, + OCKHDJDGFDJ: bool = false, + + pub const _desc_table = .{ + .LAAFPDHGMBG = fd(7, .{ .Varint = .Simple }), + .LCAKPPPACKG = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .DDNHFBNFEHB = fd(2, .{ .Varint = .Simple }), + .OCKHDJDGFDJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KEPAMJFOKDN = struct { + ELDBMBMALDC: ArrayList(u32), + IOEGBJLLDFE: ArrayList(u32), + NGOFMCJNDGO: u32 = 0, + OMFEENCKOPF: ArrayList(CHEINNKFDJN), + HDJGHCPCHMD: bool = false, + APDMCJFBCOM: ArrayList(AEALLANNPBB), + ENDPIBIJMPO: ArrayList(GNKBFNAAEED), + PJKBEFOINMK: bool = false, + CLCAABAPOFC: u32 = 0, + exp: u32 = 0, + + pub const _desc_table = .{ + .ELDBMBMALDC = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .IOEGBJLLDFE = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .NGOFMCJNDGO = fd(7, .{ .Varint = .Simple }), + .OMFEENCKOPF = fd(4, .{ .List = .{ .SubMessage = {} } }), + .HDJGHCPCHMD = fd(9, .{ .Varint = .Simple }), + .APDMCJFBCOM = fd(5, .{ .List = .{ .SubMessage = {} } }), + .ENDPIBIJMPO = fd(15, .{ .List = .{ .SubMessage = {} } }), + .PJKBEFOINMK = fd(12, .{ .Varint = .Simple }), + .CLCAABAPOFC = fd(1, .{ .Varint = .Simple }), + .exp = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHPFKPCJCEK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBKKKFGCHHM = struct { + IPGJMDCIIHH: ?EvolveBuildLevelInfo = null, + retcode: u32 = 0, + BLJGIINGHIH: ?KEPAMJFOKDN = null, + + pub const _desc_table = .{ + .IPGJMDCIIHH = fd(2, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + .BLJGIINGHIH = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NADCKBEPLAD = struct { + avatar_list: ArrayList(EvolveBuildAvatar), + LAAFPDHGMBG: u32 = 0, + EALPPJEDKMH: ?AAOEPMKPNOK = null, + + pub const _desc_table = .{ + .avatar_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .LAAFPDHGMBG = fd(15, .{ .Varint = .Simple }), + .EALPPJEDKMH = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IDDJMIOGKDM = struct { + NNIONPEAAGM: ?SceneBattleInfo = null, + IPGJMDCIIHH: ?EvolveBuildLevelInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NNIONPEAAGM = fd(15, .{ .SubMessage = {} }), + .IPGJMDCIIHH = fd(3, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNBMGPIHFBP = struct { + LAAFPDHGMBG: u32 = 0, + + pub const _desc_table = .{ + .LAAFPDHGMBG = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDJFHAPKEEI = struct { + IPGJMDCIIHH: ?EvolveBuildLevelInfo = null, + NNIONPEAAGM: ?SceneBattleInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IPGJMDCIIHH = fd(12, .{ .SubMessage = {} }), + .NNIONPEAAGM = fd(6, .{ .SubMessage = {} }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFABNCJIGPB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHFMHKIJEBA = struct { + IPGJMDCIIHH: ?EvolveBuildLevelInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IPGJMDCIIHH = fd(4, .{ .SubMessage = {} }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJNGOEJEIAK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAIMOIOEKBK = struct { + IPGJMDCIIHH: ?EvolveBuildLevelInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IPGJMDCIIHH = fd(7, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EvolveBuildFinishScNotify = struct { + wave: u32 = 0, + is_lose: bool = false, + score: u32 = 0, + level_info: ?EvolveBuildLevelInfo = null, + level_id: u32 = 0, + coin: u32 = 0, + battle_result_type: GADPGIMLECD = @enumFromInt(0), + exp: u32 = 0, + cur_period_type: u32 = 0, + + pub const _desc_table = .{ + .wave = fd(9, .{ .Varint = .Simple }), + .is_lose = fd(3, .{ .Varint = .Simple }), + .score = fd(11, .{ .Varint = .Simple }), + .level_info = fd(7, .{ .SubMessage = {} }), + .level_id = fd(15, .{ .Varint = .Simple }), + .coin = fd(8, .{ .Varint = .Simple }), + .battle_result_type = fd(10, .{ .Varint = .Simple }), + .exp = fd(12, .{ .Varint = .Simple }), + .cur_period_type = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEDKMCMBPFD = struct { + LAAFPDHGMBG: u32 = 0, + + pub const _desc_table = .{ + .LAAFPDHGMBG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHGMEKLAIFG = struct { + retcode: u32 = 0, + BHHBFDAAIPB: ?AEALLANNPBB = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .BHHBFDAAIPB = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HIOACBAONCB = struct { + DAACAHJNOCF: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .DAACAHJNOCF = fd(15, .{ .Varint = .Simple }), + .level = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFOOGLBBFDM = struct { + DAACAHJNOCF: u32 = 0, + retcode: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .DAACAHJNOCF = fd(2, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .level = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AODNJLAMIJE = struct { + DAACAHJNOCF: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .DAACAHJNOCF = fd(7, .{ .Varint = .Simple }), + .level = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPDMMAMGEED = struct { + level: u32 = 0, + retcode: u32 = 0, + DAACAHJNOCF: u32 = 0, + + pub const _desc_table = .{ + .level = fd(11, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + .DAACAHJNOCF = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BPKHACGJKMB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBMMBDAIABI = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + NGOFMCJNDGO: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(2, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + .NGOFMCJNDGO = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KONLJMPBOBA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JHOPHJKGIKA = struct { + ENDPIBIJMPO: ArrayList(GNKBFNAAEED), + retcode: u32 = 0, + CLCAABAPOFC: u32 = 0, + + pub const _desc_table = .{ + .ENDPIBIJMPO = fd(9, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(10, .{ .Varint = .Simple }), + .CLCAABAPOFC = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOAPKJDDGPA = struct { + CLCAABAPOFC: u32 = 0, + + pub const _desc_table = .{ + .CLCAABAPOFC = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEAIJHOEKAN = struct { + PJKBEFOINMK: bool = false, + HDJGHCPCHMD: bool = false, + + pub const _desc_table = .{ + .PJKBEFOINMK = fd(2, .{ .Varint = .Simple }), + .HDJGHCPCHMD = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDAIHBOGKLK = struct { + avatar_id_list: ArrayList(u32), + id: u32 = 0, + MFGNACAOBNB: i64 = 0, + FNPOIHMEPFA: u32 = 0, + + pub const _desc_table = .{ + .avatar_id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .id = fd(9, .{ .Varint = .Simple }), + .MFGNACAOBNB = fd(10, .{ .Varint = .Simple }), + .FNPOIHMEPFA = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDNAKDEHBHC = struct { + MFGNACAOBNB: i64 = 0, + BHMMNEJMBKM: u32 = 0, + id: u32 = 0, + AALNGMJIDHD: u32 = 0, + GHCELAOEOGH: u32 = 0, + avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .MFGNACAOBNB = fd(11, .{ .Varint = .Simple }), + .BHMMNEJMBKM = fd(7, .{ .Varint = .Simple }), + .id = fd(12, .{ .Varint = .Simple }), + .AALNGMJIDHD = fd(14, .{ .Varint = .Simple }), + .GHCELAOEOGH = fd(5, .{ .Varint = .Simple }), + .avatar_id_list = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKMLNBKFIKO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLNHLFDOCDP = struct { + FJONFPGDOJA: ArrayList(u32), + OFGMHLEGOOF: ArrayList(NDAIHBOGKLK), + PPIFPBNCKIO: ArrayList(PDNAKDEHBHC), + ICFMEOOHJHB: ArrayList(u32), + CHGPACJEAHL: ArrayList(u32), + IMJGNLOIFHB: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FJONFPGDOJA = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .OFGMHLEGOOF = fd(11, .{ .List = .{ .SubMessage = {} } }), + .PPIFPBNCKIO = fd(10, .{ .List = .{ .SubMessage = {} } }), + .ICFMEOOHJHB = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .CHGPACJEAHL = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .IMJGNLOIFHB = fd(15, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGAGKAGBNIF = struct { + KCOKHJOMDAJ: ?NDAIHBOGKLK = null, + + pub const _desc_table = .{ + .KCOKHJOMDAJ = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLOEDMCCJKE = struct { + retcode: u32 = 0, + KCOKHJOMDAJ: ?NDAIHBOGKLK = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .KCOKHJOMDAJ = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EECNDNPBODP = struct { + JJLCIEMGKBP: ArrayList(NDAIHBOGKLK), + + pub const _desc_table = .{ + .JJLCIEMGKBP = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHMGDIJKAMF = struct { + retcode: u32 = 0, + FECHFOAKBHA: ArrayList(NDAIHBOGKLK), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .FECHFOAKBHA = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HACCEJKKBEJ = struct { + MHAMKKHLMEO: u32 = 0, + + pub const _desc_table = .{ + .MHAMKKHLMEO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCNOHGGCKIM = struct { + retcode: u32 = 0, + MHAMKKHLMEO: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .MHAMKKHLMEO = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBJLGEODJJG = struct { + MHAMKKHLMEO: u32 = 0, + + pub const _desc_table = .{ + .MHAMKKHLMEO = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIBMPDCPOOM = struct { + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + JBNOBKKJMNN: ?ItemList = null, + MHAMKKHLMEO: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(11, .{ .SubMessage = {} }), + .JBNOBKKJMNN = fd(14, .{ .SubMessage = {} }), + .MHAMKKHLMEO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IAAMJGLMCCP = struct { + OJBOOAIDAFH: ArrayList(u32), + + pub const _desc_table = .{ + .OJBOOAIDAFH = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDGABDGODPK = struct { + retcode: u32 = 0, + ADELHONMOLG: ArrayList(ItemList), + FMJNJACABFF: ArrayList(u32), + JBNOBKKJMNN: ?ItemList = null, + ADKJIIANOOM: ?ItemList = null, + FFFABHLNBPM: ArrayList(ItemList), + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .ADELHONMOLG = fd(12, .{ .List = .{ .SubMessage = {} } }), + .FMJNJACABFF = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .JBNOBKKJMNN = fd(7, .{ .SubMessage = {} }), + .ADKJIIANOOM = fd(3, .{ .SubMessage = {} }), + .FFFABHLNBPM = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLMDMGMPMMG = struct { + ICFMEOOHJHB: ArrayList(u32), + OFGMHLEGOOF: ArrayList(NDAIHBOGKLK), + PPIFPBNCKIO: ArrayList(PDNAKDEHBHC), + CHGPACJEAHL: ArrayList(u32), + IMJGNLOIFHB: u32 = 0, + + pub const _desc_table = .{ + .ICFMEOOHJHB = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .OFGMHLEGOOF = fd(8, .{ .List = .{ .SubMessage = {} } }), + .PPIFPBNCKIO = fd(15, .{ .List = .{ .SubMessage = {} } }), + .CHGPACJEAHL = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .IMJGNLOIFHB = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCLGJEABNNC = struct { + OGCCBALLJHO: ?PDNAKDEHBHC = null, + + pub const _desc_table = .{ + .OGCCBALLJHO = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EONJJBLIGAK = struct { + retcode: u32 = 0, + OGCCBALLJHO: ?PDNAKDEHBHC = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .OGCCBALLJHO = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDALPFKHCHK = struct { + NMDJEDIJDKA: u32 = 0, + + pub const _desc_table = .{ + .NMDJEDIJDKA = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHGNKAEALMC = struct { + NMDJEDIJDKA: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NMDJEDIJDKA = fd(4, .{ .Varint = .Simple }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DEJJEPDPPIL = struct { + NMDJEDIJDKA: u32 = 0, + + pub const _desc_table = .{ + .NMDJEDIJDKA = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPCCBNICBOP = struct { + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + NMDJEDIJDKA: u32 = 0, + JBNOBKKJMNN: ?ItemList = null, + FDDOLEGBPHH: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(12, .{ .SubMessage = {} }), + .NMDJEDIJDKA = fd(6, .{ .Varint = .Simple }), + .JBNOBKKJMNN = fd(4, .{ .SubMessage = {} }), + .FDDOLEGBPHH = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNBIFBFGMGD = struct { + buff_list: ArrayList(u32), + avatar_list: ArrayList(PNEGOPHLMGB), + + pub const _desc_table = .{ + .buff_list = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JKDEMNOEBIB = struct { + ONEDDAAMDCN: ArrayList(ONEDDAAMDCNEntry), + JAMODBBMMIJ: u32 = 0, + DFLLHCPLAGJ: ArrayList(u32), + FDDKCHDGAGE: ArrayList(u32), + JDBCGDGENOC: ArrayList(u32), + NELLGGMKIBP: ArrayList(NELLGGMKIBPEntry), + FHDANACBFMJ: ArrayList(u32), + + pub const _desc_table = .{ + .ONEDDAAMDCN = fd(6, .{ .List = .{ .SubMessage = {} } }), + .JAMODBBMMIJ = fd(2, .{ .Varint = .Simple }), + .DFLLHCPLAGJ = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .FDDKCHDGAGE = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .JDBCGDGENOC = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .NELLGGMKIBP = fd(4, .{ .List = .{ .SubMessage = {} } }), + .FHDANACBFMJ = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub const ONEDDAAMDCNEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const NELLGGMKIBPEntry = struct { + key: u32 = 0, + value: ?CNBIFBFGMGD = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBPHMCEKBBG = struct { + JAMODBBMMIJ: u32 = 0, + + pub const _desc_table = .{ + .JAMODBBMMIJ = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BLDALJCGCNI = struct { + EGJCADDPEKP: ?JKDEMNOEBIB = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EGJCADDPEKP = fd(2, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKPIIAGGIEG = struct { + EGJCADDPEKP: ?JKDEMNOEBIB = null, + + pub const _desc_table = .{ + .EGJCADDPEKP = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNEGOPHLMGB = struct { + avatar_type: AvatarType = @enumFromInt(0), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(14, .{ .Varint = .Simple }), + .avatar_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDDKODNFCGM = struct { + battle_id: u32 = 0, + JAMODBBMMIJ: u32 = 0, + avatar_list: ArrayList(PNEGOPHLMGB), + buff_list: ArrayList(u32), + + pub const _desc_table = .{ + .battle_id = fd(2, .{ .Varint = .Simple }), + .JAMODBBMMIJ = fd(9, .{ .Varint = .Simple }), + .avatar_list = fd(11, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDNDKKHDDCM = struct { + retcode: u32 = 0, + JAMODBBMMIJ: u32 = 0, + battle_id: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .JAMODBBMMIJ = fd(3, .{ .Varint = .Simple }), + .battle_id = fd(10, .{ .Varint = .Simple }), + .battle_info = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOHPDDFIBDD = struct { + NDPHMPBEGOB: u32 = 0, + battle_id: u32 = 0, + JAMODBBMMIJ: u32 = 0, + + pub const _desc_table = .{ + .NDPHMPBEGOB = fd(15, .{ .Varint = .Simple }), + .battle_id = fd(6, .{ .Varint = .Simple }), + .JAMODBBMMIJ = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LBFIDJMLMLA = struct { + IKCHDHJGMOP: u32 = 0, + LKLGDCJGILM: NEHPFBIGJCP = @enumFromInt(0), + HIMGBPFDJHG: u32 = 0, + + pub const _desc_table = .{ + .IKCHDHJGMOP = fd(13, .{ .Varint = .Simple }), + .LKLGDCJGILM = fd(4, .{ .Varint = .Simple }), + .HIMGBPFDJHG = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBEHNFOBIPB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOFFGCPMKDE = struct { + PLPEJPFDMAI: ArrayList(LBFIDJMLMLA), + retcode: u32 = 0, + + pub const _desc_table = .{ + .PLPEJPFDMAI = fd(7, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HAKDEPGCKPN = struct { + NENNPJOJIEC: u32 = 0, + FBDAIIAOLLB: u32 = 0, + id: u32 = 0, + HADGLJEDCNB: NEHPFBIGJCP = @enumFromInt(0), + + pub const _desc_table = .{ + .NENNPJOJIEC = fd(7, .{ .Varint = .Simple }), + .FBDAIIAOLLB = fd(5, .{ .Varint = .Simple }), + .id = fd(1, .{ .Varint = .Simple }), + .HADGLJEDCNB = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHCNIGIKHMN = struct { + avatar_list: ArrayList(LNAPBOJEOLH), + PEJNGOODNJC: u32 = 0, + EDCEDCKBICC: u32 = 0, + id: u32 = 0, + + pub const _desc_table = .{ + .avatar_list = fd(13, .{ .List = .{ .SubMessage = {} } }), + .PEJNGOODNJC = fd(5, .{ .Varint = .Simple }), + .EDCEDCKBICC = fd(2, .{ .Varint = .Simple }), + .id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKGOKJBNNAJ = struct { + id: u32 = 0, + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .id = fd(5, .{ .Varint = .Simple }), + .battle_info = fd(2, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PAMIMEOMJAM = struct { + NCMOBOONKIJ: u32 = 0, + AJDGHADCPGM: u32 = 0, + GAEPPKNBONJ: u64 = 0, + platform: u32 = 0, + uid: u32 = 0, + OKHLBOKCMMK: u32 = 0, + OPLKHMFALGD: u32 = 0, + LGIPENPDGMC: ManagedString = .Empty, + + pub const _desc_table = .{ + .NCMOBOONKIJ = fd(4, .{ .Varint = .Simple }), + .AJDGHADCPGM = fd(5, .{ .Varint = .Simple }), + .GAEPPKNBONJ = fd(7, .{ .Varint = .Simple }), + .platform = fd(2, .{ .Varint = .Simple }), + .uid = fd(9, .{ .Varint = .Simple }), + .OKHLBOKCMMK = fd(13, .{ .Varint = .Simple }), + .OPLKHMFALGD = fd(14, .{ .Varint = .Simple }), + .LGIPENPDGMC = fd(3, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKLBDHDCDEJ = struct { + EPKIGLGBEBN: bool = false, + server_timestamp_ms: u64 = 0, + OPLKHMFALGD: u32 = 0, + secret_key_seed: u64 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EPKIGLGBEBN = fd(7, .{ .Varint = .Simple }), + .server_timestamp_ms = fd(10, .{ .Varint = .Simple }), + .OPLKHMFALGD = fd(9, .{ .Varint = .Simple }), + .secret_key_seed = fd(8, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJPKPLBIMBO = struct { + JBLNGFBMJEG: u32 = 0, + + pub const _desc_table = .{ + .JBLNGFBMJEG = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEPLKGCNFGN = struct { + kick_type: HBENCPAFOHF = @enumFromInt(0), + + pub const _desc_table = .{ + .kick_type = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMOGHNNLAHO = struct { + client_time_ms: u64 = 0, + + pub const _desc_table = .{ + .client_time_ms = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IGBEIPOGJIK = struct { + retcode: u32 = 0, + server_time_ms: u64 = 0, + client_time_ms: u64 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .server_time_ms = fd(2, .{ .Varint = .Simple }), + .client_time_ms = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFNGMLPALLN = struct { + AOHJJJHMGHM: ?PEGAEGMBJBI = null, + + pub const _desc_table = .{ + .AOHJJJHMGHM = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FightActivityGroup = struct { + taken_difficulty_level_reward_list: ArrayList(u32), + group_id: u32 = 0, + endless_max_wave: u32 = 0, + passed_max_difficulty_level: u32 = 0, + + pub const _desc_table = .{ + .taken_difficulty_level_reward_list = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .group_id = fd(6, .{ .Varint = .Simple }), + .endless_max_wave = fd(5, .{ .Varint = .Simple }), + .passed_max_difficulty_level = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHGGALKBNAG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNFLBILMMLC = struct { + world_level: u32 = 0, + PBLPDEMPPAK: ArrayList(FightActivityGroup), + retcode: u32 = 0, + AKFDJDBKKCC: bool = false, + AMONMAJKDJK: ArrayList(AMONMAJKDJKEntry), + + pub const _desc_table = .{ + .world_level = fd(11, .{ .Varint = .Simple }), + .PBLPDEMPPAK = fd(7, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(4, .{ .Varint = .Simple }), + .AKFDJDBKKCC = fd(6, .{ .Varint = .Simple }), + .AMONMAJKDJK = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const AMONMAJKDJKEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPPIMIMKMGC = struct { + PBLPDEMPPAK: ArrayList(FightActivityGroup), + AMONMAJKDJK: ArrayList(AMONMAJKDJKEntry), + + pub const _desc_table = .{ + .PBLPDEMPPAK = fd(6, .{ .List = .{ .SubMessage = {} } }), + .AMONMAJKDJK = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const AMONMAJKDJKEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KIECHAAODIJ = struct { + avatar_type: AvatarType = @enumFromInt(0), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(8, .{ .Varint = .Simple }), + .avatar_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDGGJAKNBAA = struct { + avatar_list: ArrayList(u32), + group_id: u32 = 0, + BBAGHOEKIFN: ArrayList(KIECHAAODIJ), + LHFFLOKIELE: ArrayList(u32), + IHKPKPJKKBI: u32 = 0, + + pub const _desc_table = .{ + .avatar_list = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .group_id = fd(4, .{ .Varint = .Simple }), + .BBAGHOEKIFN = fd(3, .{ .List = .{ .SubMessage = {} } }), + .LHFFLOKIELE = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .IHKPKPJKKBI = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LIBKKFPHAPE = struct { + group_id: u32 = 0, + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + IHKPKPJKKBI: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(9, .{ .Varint = .Simple }), + .battle_info = fd(13, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + .IHKPKPJKKBI = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHPIECGOEEI = struct { + IHKPKPJKKBI: u32 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .IHKPKPJKKBI = fd(8, .{ .Varint = .Simple }), + .group_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEGFBEGDECD = struct { + IHKPKPJKKBI: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .IHKPKPJKKBI = fd(9, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(7, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + .group_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EPCNFMPDMLO = struct { + rank: u32 = 0, + state: FMBMMKCIELK = @enumFromInt(0), + FDDOLEGBPHH: u32 = 0, + hp: u32 = 0, + HFCHFEFONNL: bool = false, + OENBKJDJEGE: u32 = 0, + NBDKELLGKLP: u32 = 0, + EMJOCPCFGAJ: u32 = 0, + + pub const _desc_table = .{ + .rank = fd(13, .{ .Varint = .Simple }), + .state = fd(11, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(7, .{ .Varint = .Simple }), + .hp = fd(4, .{ .Varint = .Simple }), + .HFCHFEFONNL = fd(15, .{ .Varint = .Simple }), + .OENBKJDJEGE = fd(14, .{ .Varint = .Simple }), + .NBDKELLGKLP = fd(9, .{ .Varint = .Simple }), + .EMJOCPCFGAJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPCDLEMPBEK = struct { + JKKAEELLABE: ?OHHLGOFKBNO = null, + AEHDIJLHCKM: DONOGLEODAJ = @enumFromInt(0), + DEDFKCPPGDI: i32 = 0, + IBJADECBJOF: u32 = 0, + OFBOHPBIFEE: ArrayList(EPCNFMPDMLO), + BEJANDHLCGB: ArrayList(u32), + JMGJICOEKGO: u64 = 0, + + pub const _desc_table = .{ + .JKKAEELLABE = fd(12, .{ .SubMessage = {} }), + .AEHDIJLHCKM = fd(3, .{ .Varint = .Simple }), + .DEDFKCPPGDI = fd(7, .{ .Varint = .Simple }), + .IBJADECBJOF = fd(10, .{ .Varint = .Simple }), + .OFBOHPBIFEE = fd(6, .{ .List = .{ .SubMessage = {} } }), + .BEJANDHLCGB = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .JMGJICOEKGO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AADPPEPJHLE = struct { + KKINPPHCLAM: u32 = 0, + ALBCDMAHEKP: u32 = 0, + + pub const _desc_table = .{ + .KKINPPHCLAM = fd(10, .{ .Varint = .Simple }), + .ALBCDMAHEKP = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHHLGOFKBNO = struct { + IDLKOMOAIPL: FMBMMKCIELK = @enumFromInt(0), + FDDOLEGBPHH: u32 = 0, + DBLCHMFMIDJ: u32 = 0, + AKMLEFNJPEN: u32 = 0, + MOAMNLKNBFL: u32 = 0, + BEOBIKBEJPA: ArrayList(u32), + IOCIPLFJEON: u32 = 0, + FOLHDJAICPG: u32 = 0, + FANMEJFOCIL: ?HLEMBLOIKAM = null, + DMABILNKAEM: u32 = 0, + cur_hp: u32 = 0, + + pub const _desc_table = .{ + .IDLKOMOAIPL = fd(12, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(14, .{ .Varint = .Simple }), + .DBLCHMFMIDJ = fd(4, .{ .Varint = .Simple }), + .AKMLEFNJPEN = fd(13, .{ .Varint = .Simple }), + .MOAMNLKNBFL = fd(1, .{ .Varint = .Simple }), + .BEOBIKBEJPA = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .IOCIPLFJEON = fd(8, .{ .Varint = .Simple }), + .FOLHDJAICPG = fd(7, .{ .Varint = .Simple }), + .FANMEJFOCIL = fd(15, .{ .SubMessage = {} }), + .DMABILNKAEM = fd(5, .{ .Varint = .Simple }), + .cur_hp = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOLHAFJPMEC = struct { + BOABPGEMDAB: FEOEOFGGCLE = @enumFromInt(0), + OGBINBMLPIN: ?OHHLGOFKBNO = null, + + pub const _desc_table = .{ + .BOABPGEMDAB = fd(9, .{ .Varint = .Simple }), + .OGBINBMLPIN = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCIBJCMLNAK = struct { + GMDFMEOPOJH: i32 = 0, + + pub const _desc_table = .{ + .GMDFMEOPOJH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFOACEFNLOM = struct { + data: ?HPCDLEMPBEK = null, + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + retcode: u32 = 0, + + pub const _desc_table = .{ + .data = fd(15, .{ .SubMessage = {} }), + .DOLKBPLJGNO = fd(8, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GLCPCFHCKDE = struct { + data: ?HPCDLEMPBEK = null, + + pub const _desc_table = .{ + .data = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJAFFILLFCD = struct { + CLOOBIAOFBK: ?HPCDLEMPBEK = null, + + pub const _desc_table = .{ + .CLOOBIAOFBK = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCHPMOABMEE = struct { + NCAJNCEAJHB: ?HPCDLEMPBEK = null, + DICPLJNDHHG: ?HPCDLEMPBEK = null, + + pub const _desc_table = .{ + .NCAJNCEAJHB = fd(4, .{ .SubMessage = {} }), + .DICPLJNDHHG = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KALFBFGGEEK = struct { + KKPPEBOAAIC: ?AADPPEPJHLE = null, + BPICKBJNKML: ?AADPPEPJHLE = null, + INIJHNEOBJC: ArrayList(BOLHAFJPMEC), + JEKIKFCMAIM: u32 = 0, + + pub const _desc_table = .{ + .KKPPEBOAAIC = fd(14, .{ .SubMessage = {} }), + .BPICKBJNKML = fd(12, .{ .SubMessage = {} }), + .INIJHNEOBJC = fd(11, .{ .List = .{ .SubMessage = {} } }), + .JEKIKFCMAIM = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOOCCDDMAOO = struct { + KGJCENJGLDB: bool = false, + retcode: u32 = 0, + JEKIKFCMAIM: u32 = 0, + DLICPCLOKCP: ?OHHLGOFKBNO = null, + + pub const _desc_table = .{ + .KGJCENJGLDB = fd(15, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + .JEKIKFCMAIM = fd(7, .{ .Varint = .Simple }), + .DLICPCLOKCP = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNFPNPOKPGG = struct { + state: FMBMMKCIELK = @enumFromInt(0), + IBJADECBJOF: u32 = 0, + hp: u32 = 0, + NBDKELLGKLP: u32 = 0, + FDDOLEGBPHH: u32 = 0, + + pub const _desc_table = .{ + .state = fd(15, .{ .Varint = .Simple }), + .IBJADECBJOF = fd(10, .{ .Varint = .Simple }), + .hp = fd(13, .{ .Varint = .Simple }), + .NBDKELLGKLP = fd(8, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDFLCIDEMGJ = struct { + ANNPEAOJBBB: u32 = 0, + + pub const _desc_table = .{ + .ANNPEAOJBBB = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCNIDPHMKLD = struct { + ANNPEAOJBBB: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ANNPEAOJBBB = fd(15, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BIJOOBIJJJA = struct { + BNJFEHJOJPP: u32 = 0, + ANNPEAOJBBB: u32 = 0, + + pub const _desc_table = .{ + .BNJFEHJOJPP = fd(3, .{ .Varint = .Simple }), + .ANNPEAOJBBB = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCDKFGDJLID = struct { + data: ?HPCDLEMPBEK = null, + + pub const _desc_table = .{ + .data = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AssistSimpleInfo = struct { + avatar_id: u32 = 0, + pos: u32 = 0, + dressed_skin_id: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(9, .{ .Varint = .Simple }), + .pos = fd(12, .{ .Varint = .Simple }), + .dressed_skin_id = fd(5, .{ .Varint = .Simple }), + .level = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGIBOHHAIKA = struct { + IMMDGJFIAMC: u32 = 0, + AAMBNMHOGJC: u32 = 0, + group_id: u32 = 0, + DAECKIPOPPN: u32 = 0, + + pub const _desc_table = .{ + .IMMDGJFIAMC = fd(13, .{ .Varint = .Simple }), + .AAMBNMHOGJC = fd(15, .{ .Varint = .Simple }), + .group_id = fd(1, .{ .Varint = .Simple }), + .DAECKIPOPPN = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOJMGMEKDFJ = struct { + EBLNDJPGADP: u32 = 0, + + pub const _desc_table = .{ + .EBLNDJPGADP = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFNPFCIMNHN = struct { + FCOLBJNLCHI: ArrayList(u32), + EBLNDJPGADP: u32 = 0, + + pub const _desc_table = .{ + .FCOLBJNLCHI = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .EBLNDJPGADP = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLGPKIHFFAB = struct { + NMDKBGIKADO: ?HFNPFCIMNHN = null, + + pub const _desc_table = .{ + .NMDKBGIKADO = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELJAFNFCNPI = struct { + CAPHNFCJBKG: ?EOJMGMEKDFJ = null, + HGMLKIBEBBN: ?JLGPKIHFFAB = null, + + pub const _desc_table = .{ + .CAPHNFCJBKG = fd(4, .{ .SubMessage = {} }), + .HGMLKIBEBBN = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOHGAOBIIKP = struct { + INFBHFJHKLD: ?ELJAFNFCNPI = null, + DKPLJPHGDMB: u32 = 0, + BEGNFMEADEL: ?GGIBOHHAIKA = null, + KBFFJFCGDNJ: u32 = 0, + PBKHMCFECEE: u32 = 0, + GJNPNGDMGMH: JLMBAEKILPG = @enumFromInt(0), + + pub const _desc_table = .{ + .INFBHFJHKLD = fd(7, .{ .SubMessage = {} }), + .DKPLJPHGDMB = fd(5, .{ .Varint = .Simple }), + .BEGNFMEADEL = fd(14, .{ .SubMessage = {} }), + .KBFFJFCGDNJ = fd(4, .{ .Varint = .Simple }), + .PBKHMCFECEE = fd(11, .{ .Varint = .Simple }), + .GJNPNGDMGMH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEGMPLCLOMG = struct { + CAPOLJLFIDK: bool = false, + OAPKFKJGGPP: i64 = 0, + INMOGMIPBNH: u32 = 0, + uid: u32 = 0, + MDDDOKFINDH: ManagedString = .Empty, + POECPCAMNKB: u32 = 0, + nickname: ManagedString = .Empty, + level: u32 = 0, + LNCPCIPLDHD: ArrayList(AssistSimpleInfo), + MCKKBKPOMLI: ManagedString = .Empty, + OFCEAELHIAJ: BHOFBFFAJJK = @enumFromInt(0), + OPIACEKOANJ: ManagedString = .Empty, + platform: PlatformType = @enumFromInt(0), + + pub const _desc_table = .{ + .CAPOLJLFIDK = fd(5, .{ .Varint = .Simple }), + .OAPKFKJGGPP = fd(10, .{ .Varint = .Simple }), + .INMOGMIPBNH = fd(9, .{ .Varint = .Simple }), + .uid = fd(3, .{ .Varint = .Simple }), + .MDDDOKFINDH = fd(6, .String), + .POECPCAMNKB = fd(2, .{ .Varint = .Simple }), + .nickname = fd(13, .String), + .level = fd(8, .{ .Varint = .Simple }), + .LNCPCIPLDHD = fd(1, .{ .List = .{ .SubMessage = {} } }), + .MCKKBKPOMLI = fd(4, .String), + .OFCEAELHIAJ = fd(7, .{ .Varint = .Simple }), + .OPIACEKOANJ = fd(12, .String), + .platform = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFDAFHEEAAN = struct { + APAMKMIGAOP: u32 = 0, + rank: u32 = 0, + exp: u32 = 0, + promotion: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .APAMKMIGAOP = fd(11, .{ .Varint = .Simple }), + .rank = fd(1, .{ .Varint = .Simple }), + .exp = fd(3, .{ .Varint = .Simple }), + .promotion = fd(5, .{ .Varint = .Simple }), + .level = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKNNOLLCDLF = struct { + exp: u32 = 0, + EEOLCCFMJFF: u32 = 0, + main_affix_id: u32 = 0, + APAMKMIGAOP: u32 = 0, + sub_affix_list: ArrayList(RelicAffix), + level: u32 = 0, + + pub const _desc_table = .{ + .exp = fd(13, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(5, .{ .Varint = .Simple }), + .main_affix_id = fd(15, .{ .Varint = .Simple }), + .APAMKMIGAOP = fd(8, .{ .Varint = .Simple }), + .sub_affix_list = fd(10, .{ .List = .{ .SubMessage = {} } }), + .level = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DisplayAvatarDetailInfo = struct { + rank: u32 = 0, + pos: u32 = 0, + dressed_skin_id: u32 = 0, + equipment: ?IFDAFHEEAAN = null, + relic_list: ArrayList(CKNNOLLCDLF), + all_path_unlocked_special_point_id_list: ArrayList(u32), + skilltree_list: ArrayList(AvatarSkillTree), + exp: u32 = 0, + avatar_id: u32 = 0, + all_path_special_skilltree_list: ArrayList(AvatarSkillTree), + level: u32 = 0, + promotion: u32 = 0, + + pub const _desc_table = .{ + .rank = fd(7, .{ .Varint = .Simple }), + .pos = fd(12, .{ .Varint = .Simple }), + .dressed_skin_id = fd(4, .{ .Varint = .Simple }), + .equipment = fd(5, .{ .SubMessage = {} }), + .relic_list = fd(11, .{ .List = .{ .SubMessage = {} } }), + .all_path_unlocked_special_point_id_list = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .skilltree_list = fd(2, .{ .List = .{ .SubMessage = {} } }), + .exp = fd(8, .{ .Varint = .Simple }), + .avatar_id = fd(9, .{ .Varint = .Simple }), + .all_path_special_skilltree_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .level = fd(10, .{ .Varint = .Simple }), + .promotion = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNAEJJABLKK = struct { + KJNOOOJDGDN: u32 = 0, + NCCNLKFCAKM: u32 = 0, + JMGKJKDLIFI: u32 = 0, + DGJKPAAINFI: u32 = 0, + ONEEHDCGMOH: u32 = 0, + + pub const _desc_table = .{ + .KJNOOOJDGDN = fd(3, .{ .Varint = .Simple }), + .NCCNLKFCAKM = fd(1, .{ .Varint = .Simple }), + .JMGKJKDLIFI = fd(14, .{ .Varint = .Simple }), + .DGJKPAAINFI = fd(7, .{ .Varint = .Simple }), + .ONEEHDCGMOH = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MAPBIMHMJLO = struct { + OOIOMMKOIAE: u32 = 0, + DKPLJPHGDMB: u32 = 0, + HNICFKBEKJO: u32 = 0, + INMEAGINKPN: u32 = 0, + CPIKKMDOKHA: u32 = 0, + MGDIMDLPOGA: u32 = 0, + BIOJHIBFELK: u32 = 0, + HLHLPCCFKNO: ?JNAEJJABLKK = null, + MFMOAJONBBF: u32 = 0, + + pub const _desc_table = .{ + .OOIOMMKOIAE = fd(15, .{ .Varint = .Simple }), + .DKPLJPHGDMB = fd(7, .{ .Varint = .Simple }), + .HNICFKBEKJO = fd(14, .{ .Varint = .Simple }), + .INMEAGINKPN = fd(8, .{ .Varint = .Simple }), + .CPIKKMDOKHA = fd(3, .{ .Varint = .Simple }), + .MGDIMDLPOGA = fd(4, .{ .Varint = .Simple }), + .BIOJHIBFELK = fd(10, .{ .Varint = .Simple }), + .HLHLPCCFKNO = fd(2, .{ .SubMessage = {} }), + .MFMOAJONBBF = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNCLPGJGHHK = struct { + KEACGBKOFKF: bool = false, + DAFHJJEDMOF: bool = false, + KDAKDMCGFND: bool = false, + BPELFJGIJID: bool = false, + DKLJGCEHPJL: bool = false, + EPMCKMCDIGB: JLMBAEKILPG = @enumFromInt(0), + + pub const _desc_table = .{ + .KEACGBKOFKF = fd(13, .{ .Varint = .Simple }), + .DAFHJJEDMOF = fd(8, .{ .Varint = .Simple }), + .KDAKDMCGFND = fd(11, .{ .Varint = .Simple }), + .BPELFJGIJID = fd(7, .{ .Varint = .Simple }), + .DKLJGCEHPJL = fd(5, .{ .Varint = .Simple }), + .EPMCKMCDIGB = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAIDCEFAPAB = struct { + NIKHKCMAFMM: ArrayList(GGIBOHHAIKA), + INFBHFJHKLD: ?ELJAFNFCNPI = null, + + pub const _desc_table = .{ + .NIKHKCMAFMM = fd(4, .{ .List = .{ .SubMessage = {} } }), + .INFBHFJHKLD = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHKCIHEODML = struct { + CAPOLJLFIDK: bool = false, + world_level: u32 = 0, + MLDNNOMLHJD: ?DNCLPGJGHHK = null, + LFFJMADBHNN: u32 = 0, + INMOGMIPBNH: u32 = 0, + OPIACEKOANJ: ManagedString = .Empty, + MDDDOKFINDH: ManagedString = .Empty, + HGLDGCLGLNG: ArrayList(DisplayAvatarDetailInfo), + DBNOFKMNOAC: ArrayList(DisplayAvatarDetailInfo), + platform: PlatformType = @enumFromInt(0), + BHEAOIOAGEC: ?MAPBIMHMJLO = null, + JLLPKCHGKOP: ?CAIDCEFAPAB = null, + uid: u32 = 0, + COAELHIGPNG: u32 = 0, + level: u32 = 0, + nickname: ManagedString = .Empty, + HNADOAKOMEE: bool = false, + MCKKBKPOMLI: ManagedString = .Empty, + + pub const _desc_table = .{ + .CAPOLJLFIDK = fd(11, .{ .Varint = .Simple }), + .world_level = fd(6, .{ .Varint = .Simple }), + .MLDNNOMLHJD = fd(1265, .{ .SubMessage = {} }), + .LFFJMADBHNN = fd(10, .{ .Varint = .Simple }), + .INMOGMIPBNH = fd(12, .{ .Varint = .Simple }), + .OPIACEKOANJ = fd(3, .String), + .MDDDOKFINDH = fd(4, .String), + .HGLDGCLGLNG = fd(8, .{ .List = .{ .SubMessage = {} } }), + .DBNOFKMNOAC = fd(1854, .{ .List = .{ .SubMessage = {} } }), + .platform = fd(5, .{ .Varint = .Simple }), + .BHEAOIOAGEC = fd(13, .{ .SubMessage = {} }), + .JLLPKCHGKOP = fd(1079, .{ .SubMessage = {} }), + .uid = fd(9, .{ .Varint = .Simple }), + .COAELHIGPNG = fd(15, .{ .Varint = .Simple }), + .level = fd(14, .{ .Varint = .Simple }), + .nickname = fd(2, .String), + .HNADOAKOMEE = fd(1, .{ .Varint = .Simple }), + .MCKKBKPOMLI = fd(7, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOAJBLNMOGO = struct { + EFHDEANOPHB: ?OOHGAOBIIKP = null, + OKCHMINCCNE: ?HEGMPLCLOMG = null, + MMJCCANODOJ: PlayingState = @enumFromInt(0), + KKMACPKIFKP: ManagedString = .Empty, + KFDOAHPKDMC: bool = false, + + pub const _desc_table = .{ + .EFHDEANOPHB = fd(2, .{ .SubMessage = {} }), + .OKCHMINCCNE = fd(1, .{ .SubMessage = {} }), + .MMJCCANODOJ = fd(14, .{ .Varint = .Simple }), + .KKMACPKIFKP = fd(13, .String), + .KFDOAHPKDMC = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFPFLKBHFCB = struct { + OKCHMINCCNE: ?HEGMPLCLOMG = null, + GDNGGMKFHOP: i64 = 0, + + pub const _desc_table = .{ + .OKCHMINCCNE = fd(9, .{ .SubMessage = {} }), + .GDNGGMKFHOP = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MAOJKNNONOJ = struct { + OPGFDIKLAGL: bool = false, + OKCHMINCCNE: ?HEGMPLCLOMG = null, + + pub const _desc_table = .{ + .OPGFDIKLAGL = fd(8, .{ .Varint = .Simple }), + .OKCHMINCCNE = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMBBBGJELBJ = struct { + DKOOHHLMGBJ: ?DisplayAvatarDetailInfo = null, + OKCHMINCCNE: ?HEGMPLCLOMG = null, + + pub const _desc_table = .{ + .DKOOHHLMGBJ = fd(2, .{ .SubMessage = {} }), + .OKCHMINCCNE = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOJCGNJFHHD = struct { + INMOGMIPBNH: u32 = 0, + EKONPNJPPAF: u32 = 0, + platform: PlatformType = @enumFromInt(0), + MCKKBKPOMLI: ManagedString = .Empty, + level: u32 = 0, + KKMACPKIFKP: ManagedString = .Empty, + uid: u32 = 0, + nickname: ManagedString = .Empty, + + pub const _desc_table = .{ + .INMOGMIPBNH = fd(4, .{ .Varint = .Simple }), + .EKONPNJPPAF = fd(7, .{ .Varint = .Simple }), + .platform = fd(9, .{ .Varint = .Simple }), + .MCKKBKPOMLI = fd(1, .String), + .level = fd(10, .{ .Varint = .Simple }), + .KKMACPKIFKP = fd(15, .String), + .uid = fd(13, .{ .Varint = .Simple }), + .nickname = fd(12, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CDPNEMEEBKK = struct { + FDDOLEGBPHH: u32 = 0, + KKMACPKIFKP: ManagedString = .Empty, + ANGCCKJMBBG: u32 = 0, + DKFHAHHJILF: u32 = 0, + KAGFGNKJPOA: u32 = 0, + lineup_list: ArrayList(NCINPBMHNOF), + OKCHMINCCNE: ?HEGMPLCLOMG = null, + + pub const _desc_table = .{ + .FDDOLEGBPHH = fd(9, .{ .Varint = .Simple }), + .KKMACPKIFKP = fd(13, .String), + .ANGCCKJMBBG = fd(15, .{ .Varint = .Simple }), + .DKFHAHHJILF = fd(4, .{ .Varint = .Simple }), + .KAGFGNKJPOA = fd(7, .{ .Varint = .Simple }), + .lineup_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .OKCHMINCCNE = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJFNKFHDIOO = struct { + AAMBNMHOGJC: u32 = 0, + group_id: u32 = 0, + ADMPDKACMMP: ?FPJBPNBCBAL = null, + JCEOOEGJKNE: ?MJAPECHBENG = null, + LBKCIKIDLCG: ?EFBDHLEJDJM = null, + + pub const _desc_table = .{ + .AAMBNMHOGJC = fd(8, .{ .Varint = .Simple }), + .group_id = fd(3, .{ .Varint = .Simple }), + .ADMPDKACMMP = fd(1599, .{ .SubMessage = {} }), + .JCEOOEGJKNE = fd(942, .{ .SubMessage = {} }), + .LBKCIKIDLCG = fd(1787, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPPMNNPPFFK = struct { + IMIIPMGOHBP: ?KJPBGKLIKOM = null, + EGKOJHEIOHH: u32 = 0, + + pub const _desc_table = .{ + .IMIIPMGOHBP = fd(14, .{ .SubMessage = {} }), + .EGKOJHEIOHH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALGMHHFCACA = struct { + LGGNNMFBOKH: u32 = 0, + BDBFLHCAHGP: ?IOBLHLMIDAE = null, + + pub const _desc_table = .{ + .LGGNNMFBOKH = fd(15, .{ .Varint = .Simple }), + .BDBFLHCAHGP = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOGCENOKCID = struct { + IJMBJFAGBBB: ?KPPMNNPPFFK = null, + ONLIPDAKFDE: ?ALGMHHFCACA = null, + + pub const _desc_table = .{ + .IJMBJFAGBBB = fd(232, .{ .SubMessage = {} }), + .ONLIPDAKFDE = fd(665, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLNCNPHPNJB = struct { + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJHMPNNALNL = struct { + ONBDKKFHLAO: u32 = 0, + PDJJLJGBMLD: u32 = 0, + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(2, .{ .Varint = .Simple }), + .PDJJLJGBMLD = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJDHPPFMDJO = struct { + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLHELHNHLCI = struct { + BKMODLIJKGO: DevelopmentType = @enumFromInt(0), + time: i64 = 0, + GIJPNCCEGEK: ?HLNCNPHPNJB = null, + AIIEOGKGBIJ: ?NJDHPPFMDJO = null, + avatar_id: u32 = 0, + PDIGONIOFGC: u32 = 0, + LLJLJLHAKKB: u32 = 0, + CEFPILPICIN: ?CJHMPNNALNL = null, + + pub const _desc_table = .{ + .BKMODLIJKGO = fd(8, .{ .Varint = .Simple }), + .time = fd(7, .{ .Varint = .Simple }), + .GIJPNCCEGEK = fd(1867, .{ .SubMessage = {} }), + .AIIEOGKGBIJ = fd(1350, .{ .SubMessage = {} }), + .avatar_id = fd(1495, .{ .Varint = .Simple }), + .PDIGONIOFGC = fd(936, .{ .Varint = .Simple }), + .LLJLJLHAKKB = fd(955, .{ .Varint = .Simple }), + .CEFPILPICIN = fd(606, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGMDAOAMDCK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BIDJGIIMHOI = struct { + retcode: u32 = 0, + GCFLHBCOBNL: ArrayList(MOAJBLNMOGO), + EGIPFDNKCCN: ArrayList(HEGMPLCLOMG), + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .GCFLHBCOBNL = fd(6, .{ .List = .{ .SubMessage = {} } }), + .EGIPFDNKCCN = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHKKJCMDADO = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOLEOMLJAHI = struct { + DFPOALOKHEL: ?DHKCIHEODML = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DFPOALOKHEL = fd(14, .{ .SubMessage = {} }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICBKGOHCANP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPEPOGFMKNH = struct { + retcode: u32 = 0, + FMJLBPEDGHM: ArrayList(MFPFLKBHFCB), + CENFFNDAIKK: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .FMJLBPEDGHM = fd(11, .{ .List = .{ .SubMessage = {} } }), + .CENFFNDAIKK = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEDFFIHPNPF = struct { + LGEKDBJJLNI: KAMMNBKBEOL = @enumFromInt(0), + uid: u32 = 0, + + pub const _desc_table = .{ + .LGEKDBJJLNI = fd(12, .{ .Varint = .Simple }), + .uid = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLIODEGKIIL = struct { + uid: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(6, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALILNGBFPJP = struct { + HBOADIPOGNK: ?MFPFLKBHFCB = null, + + pub const _desc_table = .{ + .HBOADIPOGNK = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCIACMJCPHJ = struct { + AONAMPODGLJ: bool = false, + uid: u32 = 0, + + pub const _desc_table = .{ + .AONAMPODGLJ = fd(15, .{ .Varint = .Simple }), + .uid = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMJBBJGGFDM = struct { + retcode: u32 = 0, + BBBEBCEDFBH: ?MOAJBLNMOGO = null, + uid: u32 = 0, + AONAMPODGLJ: bool = false, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .BBBEBCEDFBH = fd(11, .{ .SubMessage = {} }), + .uid = fd(3, .{ .Varint = .Simple }), + .AONAMPODGLJ = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMJPOKCMEGO = struct { + BBBEBCEDFBH: ?MOAJBLNMOGO = null, + uid: u32 = 0, + AONAMPODGLJ: bool = false, + + pub const _desc_table = .{ + .BBBEBCEDFBH = fd(14, .{ .SubMessage = {} }), + .uid = fd(13, .{ .Varint = .Simple }), + .AONAMPODGLJ = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDALEEMPHKM = struct { + uid: u32 = 0, + FLPBPNHBFJK: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(11, .{ .Varint = .Simple }), + .FLPBPNHBFJK = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDNJALFNDMF = struct { + retcode: u32 = 0, + uid: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .uid = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMGECLKGBHP = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DDBGLEFCALM = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFDDIMDLLGB = struct { + retcode: u32 = 0, + black_info: ?HEGMPLCLOMG = null, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .black_info = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBLKALMKFJC = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLJNDGOEIDE = struct { + CLBGEIOMCOJ: bool = false, + + pub const _desc_table = .{ + .CLBGEIOMCOJ = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NINOAFAGMGL = struct { + LNKHMOMINDF: ArrayList(MAOJKNNONOJ), + retcode: u32 = 0, + + pub const _desc_table = .{ + .LNKHMOMINDF = fd(13, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKECLEIJOBO = struct { + KKMACPKIFKP: ManagedString = .Empty, + uid: u32 = 0, + + pub const _desc_table = .{ + .KKMACPKIFKP = fd(8, .String), + .uid = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEIKJBCBKCL = struct { + retcode: u32 = 0, + KKMACPKIFKP: ManagedString = .Empty, + uid: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .KKMACPKIFKP = fd(2, .String), + .uid = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDEPMIHJDJP = struct { + GIOCFBEKILC: u32 = 0, + JODLFLAOCON: ManagedString = .Empty, + uid: u32 = 0, + + pub const _desc_table = .{ + .GIOCFBEKILC = fd(11, .{ .Varint = .Simple }), + .JODLFLAOCON = fd(6, .String), + .uid = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GPGLNMJFMBG = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MBAMNCNKDHJ = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APPNEDHCCCK = struct { + uid: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(4, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKKHOAKCFHN = struct { + NHLFDHHPBPE: ArrayList(u32), + CLBGEIOMCOJ: bool = false, + + pub const _desc_table = .{ + .NHLFDHHPBPE = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .CLBGEIOMCOJ = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJPHFMEMDHP = struct { + retcode: u32 = 0, + GJGIEMDHBJP: ArrayList(u32), + FCPLJCAIJBC: ArrayList(HEGMPLCLOMG), + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .GJGIEMDHBJP = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .FCPLJCAIJBC = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLFLGCEEECI = struct { + CLBGEIOMCOJ: bool = false, + DOLIBHOKLJB: bool = false, + + pub const _desc_table = .{ + .CLBGEIOMCOJ = fd(4, .{ .Varint = .Simple }), + .DOLIBHOKLJB = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOJOEJKDCGE = struct { + NFILMOHONIC: ArrayList(PMBBBGJELBJ), + retcode: u32 = 0, + + pub const _desc_table = .{ + .NFILMOHONIC = fd(9, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBMHEANPFFG = struct { + avatar_id: u32 = 0, + uid: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(9, .{ .Varint = .Simple }), + .uid = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGEAMLAIGPJ = struct { + uid: u32 = 0, + retcode: u32 = 0, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(11, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + .avatar_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOCODHEJJIP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLALKJBOADL = struct { + retcode: u32 = 0, + MJNGLNDJLHM: ?PMBBBGJELBJ = null, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .MJNGLNDJLHM = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BAOAOACGDMN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGMBJNFNCIE = struct { + MANBHDBIGDC: u32 = 0, + GHKNDMDIDDK: ArrayList(u32), + retcode: u32 = 0, + NFGCOFGINCG: u32 = 0, + MCCLBGOGKBJ: u32 = 0, + + pub const _desc_table = .{ + .MANBHDBIGDC = fd(15, .{ .Varint = .Simple }), + .GHKNDMDIDDK = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(14, .{ .Varint = .Simple }), + .NFGCOFGINCG = fd(3, .{ .Varint = .Simple }), + .MCCLBGOGKBJ = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFKOKINMNJP = struct { + MANBHDBIGDC: u32 = 0, + + pub const _desc_table = .{ + .MANBHDBIGDC = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGILDEDPOEL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIAALGKNEAE = struct { + retcode: u32 = 0, + DILFGBPCAPM: ArrayList(DOJCGNJFHHD), + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .DILFGBPCAPM = fd(13, .{ .List = .{ .SubMessage = {} } }), + .ADKJIIANOOM = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBMLNJABLLM = struct { + MJNGLNDJLHM: ?PMBBBGJELBJ = null, + + pub const _desc_table = .{ + .MJNGLNDJLHM = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEJBPEDECGE = struct { + platform: PlatformType = @enumFromInt(0), + AOBDBHGCKCM: ArrayList(ManagedString), + + pub const _desc_table = .{ + .platform = fd(4, .{ .Varint = .Simple }), + .AOBDBHGCKCM = fd(7, .{ .List = .String }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFBBEFCHFKH = struct { + retcode: u32 = 0, + LNKHMOMINDF: ArrayList(HEGMPLCLOMG), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .LNKHMOMINDF = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKOLBOHOEOJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNBHPJALOLE = struct { + GECAOAAMEPE: ArrayList(u32), + OBCELADBCPA: bool = false, + retcode: u32 = 0, + NMPKMCIHIGI: ArrayList(u32), + EAGFGMLIBHP: bool = false, + + pub const _desc_table = .{ + .GECAOAAMEPE = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .OBCELADBCPA = fd(15, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .NMPKMCIHIGI = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .EAGFGMLIBHP = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJPKALBPMIA = struct { + CCGBOLBKOCC: bool = false, + + pub const _desc_table = .{ + .CCGBOLBKOCC = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAKLFOCEHFP = struct { + CCGBOLBKOCC: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CCGBOLBKOCC = fd(3, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOJIHIGKFCN = struct { + PDOFIIHOCFH: bool = false, + uid: u32 = 0, + + pub const _desc_table = .{ + .PDOFIIHOCFH = fd(1, .{ .Varint = .Simple }), + .uid = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODFCEEGNNNI = struct { + PDOFIIHOCFH: bool = false, + retcode: u32 = 0, + uid: u32 = 0, + + pub const _desc_table = .{ + .PDOFIIHOCFH = fd(4, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + .uid = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJHHMBLOBDL = struct { + PAFMFIBJJBA: u32 = 0, + DMEGPIKBEKI: AssistAvatarType = @enumFromInt(0), + CLBGEIOMCOJ: bool = false, + FLOKNFOIPCM: ArrayList(u32), + LGICIAEBMON: ArrayList(u32), + + pub const _desc_table = .{ + .PAFMFIBJJBA = fd(6, .{ .Varint = .Simple }), + .DMEGPIKBEKI = fd(5, .{ .Varint = .Simple }), + .CLBGEIOMCOJ = fd(2, .{ .Varint = .Simple }), + .FLOKNFOIPCM = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .LGICIAEBMON = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCLNAAEFMGP = struct { + NFILMOHONIC: ArrayList(PMBBBGJELBJ), + PAFMFIBJJBA: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NFILMOHONIC = fd(2, .{ .List = .{ .SubMessage = {} } }), + .PAFMFIBJJBA = fd(13, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKNLJNNBLKL = struct { + LGNHDNODOLM: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IBNODOMPLAI = struct { + retcode: u32 = 0, + NGPEFLIMHLH: ArrayList(CDPNEMEEBKK), + NMMIEEIDOBL: bool = false, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .NGPEFLIMHLH = fd(1, .{ .List = .{ .SubMessage = {} } }), + .NMMIEEIDOBL = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAKBBEJAMDC = struct { + LGNHDNODOLM: u32 = 0, + uid: u32 = 0, + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(12, .{ .Varint = .Simple }), + .uid = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MLDLJGGODJO = struct { + LGNHDNODOLM: u32 = 0, + retcode: u32 = 0, + uid: u32 = 0, + LNEEBNHLMIM: ArrayList(DisplayAvatarDetailInfo), + + pub const _desc_table = .{ + .LGNHDNODOLM = fd(11, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .uid = fd(2, .{ .Varint = .Simple }), + .LNEEBNHLMIM = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGNGKCMJMLI = struct { + group_id: u32 = 0, + uid: u32 = 0, + EEOLCCFMJFF: JLMBAEKILPG = @enumFromInt(0), + + pub const _desc_table = .{ + .group_id = fd(10, .{ .Varint = .Simple }), + .uid = fd(6, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNFIEHDOIFF = struct { + retcode: u32 = 0, + uid: u32 = 0, + NOAJHHAMNGH: ?OJFNKFHDIOO = null, + HAJLPBBLBNK: ?KOGCENOKCID = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .uid = fd(4, .{ .Varint = .Simple }), + .NOAJHHAMNGH = fd(620, .{ .SubMessage = {} }), + .HAJLPBBLBNK = fd(348, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AMMMDHAAPAH = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPIBPDIJDHJ = struct { + retcode: u32 = 0, + DMKIKGGOBAF: ArrayList(OLHELHNHLCI), + uid: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .DMKIKGGOBAF = fd(9, .{ .List = .{ .SubMessage = {} } }), + .uid = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGFAAKMKMBL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GachaCeilingAvatar = struct { + RepeatedCnt: u32 = 0, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .RepeatedCnt = fd(13, .{ .Varint = .Simple }), + .avatar_id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIMODDHINLF = struct { + avatar_list: ArrayList(GachaCeilingAvatar), + OOMMDOHHKLA: u32 = 0, + GJPJILICEJP: bool = false, + + pub const _desc_table = .{ + .avatar_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .OOMMDOHHKLA = fd(5, .{ .Varint = .Simple }), + .GJPJILICEJP = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCGGFGBHCDH = struct { + CHFGAONACNK: ArrayList(u32), + MOKHDEDFKIK: ManagedString = .Empty, + PPJDLLMODMJ: ManagedString = .Empty, + IPCBPIECKFL: ?GIMODDHINLF = null, + MNNEBOGGKAL: u32 = 0, + end_time: i64 = 0, + ABKILLHGKKN: u32 = 0, + FJMKLFPAENC: ArrayList(u32), + ENCAIBLKLHH: u32 = 0, + begin_time: i64 = 0, + + pub const _desc_table = .{ + .CHFGAONACNK = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .MOKHDEDFKIK = fd(7, .String), + .PPJDLLMODMJ = fd(14, .String), + .IPCBPIECKFL = fd(10, .{ .SubMessage = {} }), + .MNNEBOGGKAL = fd(3, .{ .Varint = .Simple }), + .end_time = fd(1, .{ .Varint = .Simple }), + .ABKILLHGKKN = fd(12, .{ .Varint = .Simple }), + .FJMKLFPAENC = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .ENCAIBLKLHH = fd(9, .{ .Varint = .Simple }), + .begin_time = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IEPANKBNMEF = struct { + MGFCLGMCKGF: u32 = 0, + retcode: u32 = 0, + LGLBPKOCIFK: u32 = 0, + HAHOMIBEADN: ArrayList(OCGGFGBHCDH), + AMJNKLBFHCH: u32 = 0, + PCLBNCPJNKN: u32 = 0, + + pub const _desc_table = .{ + .MGFCLGMCKGF = fd(2, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + .LGLBPKOCIFK = fd(15, .{ .Varint = .Simple }), + .HAHOMIBEADN = fd(12, .{ .List = .{ .SubMessage = {} } }), + .AMJNKLBFHCH = fd(13, .{ .Varint = .Simple }), + .PCLBNCPJNKN = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJJAPKHDMBI = struct { + PJPHAIAHMHF: u32 = 0, + ABKILLHGKKN: u32 = 0, + LGLBPKOCIFK: u32 = 0, + NDGKNOMLDDP: u32 = 0, + + pub const _desc_table = .{ + .PJPHAIAHMHF = fd(6, .{ .Varint = .Simple }), + .ABKILLHGKKN = fd(12, .{ .Varint = .Simple }), + .LGLBPKOCIFK = fd(14, .{ .Varint = .Simple }), + .NDGKNOMLDDP = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBAFMLKBMIG = struct { + OCJDMDEGAKC: ?Item = null, + FHFIGBKCGIF: bool = false, + OHELFNPJMAG: ?ItemList = null, + MFGNOPCJBHA: ?ItemList = null, + + pub const _desc_table = .{ + .OCJDMDEGAKC = fd(3, .{ .SubMessage = {} }), + .FHFIGBKCGIF = fd(9, .{ .Varint = .Simple }), + .OHELFNPJMAG = fd(12, .{ .SubMessage = {} }), + .MFGNOPCJBHA = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LAGCCNILJIK = struct { + PCLBNCPJNKN: u32 = 0, + ABKILLHGKKN: u32 = 0, + OOMMDOHHKLA: u32 = 0, + retcode: u32 = 0, + EJAPJPIDPOA: u32 = 0, + MNNEBOGGKAL: u32 = 0, + ENCAIBLKLHH: u32 = 0, + GFKMEPDLNHC: ArrayList(GBAFMLKBMIG), + PJPHAIAHMHF: u32 = 0, + + pub const _desc_table = .{ + .PCLBNCPJNKN = fd(5, .{ .Varint = .Simple }), + .ABKILLHGKKN = fd(10, .{ .Varint = .Simple }), + .OOMMDOHHKLA = fd(3, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + .EJAPJPIDPOA = fd(12, .{ .Varint = .Simple }), + .MNNEBOGGKAL = fd(1, .{ .Varint = .Simple }), + .ENCAIBLKLHH = fd(7, .{ .Varint = .Simple }), + .GFKMEPDLNHC = fd(2, .{ .List = .{ .SubMessage = {} } }), + .PJPHAIAHMHF = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADAHJNIILFK = struct { + OMMCBEDJCMO: u32 = 0, + + pub const _desc_table = .{ + .OMMCBEDJCMO = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMLLIBFAECO = struct { + OMMCBEDJCMO: u32 = 0, + IPCBPIECKFL: ?GIMODDHINLF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .OMMCBEDJCMO = fd(14, .{ .Varint = .Simple }), + .IPCBPIECKFL = fd(11, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHPHILIIEBE = struct { + OMMCBEDJCMO: u32 = 0, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .OMMCBEDJCMO = fd(14, .{ .Varint = .Simple }), + .avatar_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDJAMJCLILC = struct { + avatar_id: u32 = 0, + MFGNOPCJBHA: ?ItemList = null, + OMMCBEDJCMO: u32 = 0, + retcode: u32 = 0, + IPCBPIECKFL: ?GIMODDHINLF = null, + + pub const _desc_table = .{ + .avatar_id = fd(1, .{ .Varint = .Simple }), + .MFGNOPCJBHA = fd(8, .{ .SubMessage = {} }), + .OMMCBEDJCMO = fd(5, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + .IPCBPIECKFL = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMDLKKBNKPD = struct { + IAGJGJKGJBL: u32 = 0, + APGNHJPDNBC: bool = false, + + pub const _desc_table = .{ + .IAGJGJKGJBL = fd(1, .{ .Varint = .Simple }), + .APGNHJPDNBC = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHAKGMKCBPK = struct { + JAOCGOEMJPI: bool = false, + BKHNLBNBKNF: ECLMHPDLLPN = @enumFromInt(0), + NNEEAINEBPM: bool = false, + GPPDNODOEBH: u32 = 0, + step: ALEFJKKKEGA = @enumFromInt(0), + + pub const _desc_table = .{ + .JAOCGOEMJPI = fd(11, .{ .Varint = .Simple }), + .BKHNLBNBKNF = fd(10, .{ .Varint = .Simple }), + .NNEEAINEBPM = fd(1, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(5, .{ .Varint = .Simple }), + .step = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAIGCJKNEGA = struct { + GPPDNODOEBH: u32 = 0, + IJNKELEANJD: u32 = 0, + + pub const _desc_table = .{ + .GPPDNODOEBH = fd(10, .{ .Varint = .Simple }), + .IJNKELEANJD = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const INBEMPLNJHP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKODOIGLLHF = struct { + retcode: u32 = 0, + HIANKELKFIG: ArrayList(PHAKGMKCBPK), + OGPOFBLDBPP: ArrayList(MMDLKKBNKPD), + BIKNELBHPEE: ArrayList(OAIGCJKNEGA), + IENCKNKDBDI: BJGCCNNMPHI = @enumFromInt(0), + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .HIANKELKFIG = fd(6, .{ .List = .{ .SubMessage = {} } }), + .OGPOFBLDBPP = fd(15, .{ .List = .{ .SubMessage = {} } }), + .BIKNELBHPEE = fd(8, .{ .List = .{ .SubMessage = {} } }), + .IENCKNKDBDI = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBPKBGFMOFO = struct { + MIBEKFHNCCC: ECLMHPDLLPN = @enumFromInt(0), + GPPDNODOEBH: u32 = 0, + PKBMEHAFBCH: u32 = 0, + + pub const _desc_table = .{ + .MIBEKFHNCCC = fd(9, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(7, .{ .Varint = .Simple }), + .PKBMEHAFBCH = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GOBADOMPKLM = struct { + ALIMAOAEFPA: ECLMHPDLLPN = @enumFromInt(0), + GPPDNODOEBH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ALIMAOAEFPA = fd(7, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(10, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKMIDPHDCCF = struct { + PKBMEHAFBCH: u32 = 0, + GPPDNODOEBH: u32 = 0, + LHFFLOKIELE: ?ItemList = null, + + pub const _desc_table = .{ + .PKBMEHAFBCH = fd(2, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(13, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBOBOHHLBMD = struct { + GPPDNODOEBH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GPPDNODOEBH = fd(11, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDCJKFOOLPL = struct { + IAGJGJKGJBL: u32 = 0, + PKBMEHAFBCH: u32 = 0, + GPPDNODOEBH: u32 = 0, + + pub const _desc_table = .{ + .IAGJGJKGJBL = fd(5, .{ .Varint = .Simple }), + .PKBMEHAFBCH = fd(14, .{ .Varint = .Simple }), + .GPPDNODOEBH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOHIMDNLDFN = struct { + GPPDNODOEBH: u32 = 0, + retcode: u32 = 0, + EADGDKMCPCI: ?ItemList = null, + IAGJGJKGJBL: u32 = 0, + + pub const _desc_table = .{ + .GPPDNODOEBH = fd(12, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + .EADGDKMCPCI = fd(3, .{ .SubMessage = {} }), + .IAGJGJKGJBL = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AMJOKEIIHDD = struct { + IENCKNKDBDI: BJGCCNNMPHI = @enumFromInt(0), + BIKNELBHPEE: ArrayList(OAIGCJKNEGA), + CMGJFCDKEBD: ArrayList(MMDLKKBNKPD), + NAGJFPOJIPC: ArrayList(PHAKGMKCBPK), + + pub const _desc_table = .{ + .IENCKNKDBDI = fd(8, .{ .Varint = .Simple }), + .BIKNELBHPEE = fd(12, .{ .List = .{ .SubMessage = {} } }), + .CMGJFCDKEBD = fd(2, .{ .List = .{ .SubMessage = {} } }), + .NAGJFPOJIPC = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCBJCLKBKDI = struct { + BPIMBBDFIII: ?OAIGCJKNEGA = null, + + pub const _desc_table = .{ + .BPIMBBDFIII = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPOEFJNPCGH = struct { + BPIMBBDFIII: ?OAIGCJKNEGA = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .BPIMBBDFIII = fd(9, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MLMGHLFKFLM = struct { + NHPHHAPJODG: ArrayList(u32), + ABCABFMCNAL: u32 = 0, + + pub const _desc_table = .{ + .NHPHHAPJODG = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .ABCABFMCNAL = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJEIKPEFCMI = struct { + HEMJIDNEAHO: u32 = 0, + LGNHDNODOLM: u32 = 0, + BLJLFMGLKHM: bool = false, + + pub const _desc_table = .{ + .HEMJIDNEAHO = fd(15, .{ .Varint = .Simple }), + .LGNHDNODOLM = fd(9, .{ .Varint = .Simple }), + .BLJLFMGLKHM = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HeliobusChallengeLineup = struct { + skill_id: u32 = 0, + group_id: u32 = 0, + avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .skill_id = fd(9, .{ .Varint = .Simple }), + .group_id = fd(13, .{ .Varint = .Simple }), + .avatar_id_list = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHPHJMFJCLH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOJFJONKEFP = struct { + retcode: u32 = 0, + MGKDFNBENAI: u32 = 0, + OHLDFLFFDAA: ?MLMGHLFKFLM = null, + NIKHKCMAFMM: ArrayList(IJEIKPEFCMI), + FGMLGNAIGPM: u32 = 0, + phase: u32 = 0, + IBHMFOOJMPO: ArrayList(FHJFPEPDKCH), + level: u32 = 0, + JKHNEGPJABJ: u32 = 0, + AALKCALNHIL: ArrayList(HeliobusChallengeLineup), + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .MGKDFNBENAI = fd(14, .{ .Varint = .Simple }), + .OHLDFLFFDAA = fd(7, .{ .SubMessage = {} }), + .NIKHKCMAFMM = fd(8, .{ .List = .{ .SubMessage = {} } }), + .FGMLGNAIGPM = fd(6, .{ .Varint = .Simple }), + .phase = fd(15, .{ .Varint = .Simple }), + .IBHMFOOJMPO = fd(5, .{ .List = .{ .SubMessage = {} } }), + .level = fd(1, .{ .Varint = .Simple }), + .JKHNEGPJABJ = fd(9, .{ .Varint = .Simple }), + .AALKCALNHIL = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHALCPBJDPO = struct { + ILGOCAEIFPF: u32 = 0, + KJNKFJEBPAL: ArrayList(GHALCPBJDPO), + JAHBHEJKDPB: u32 = 0, + + pub const _desc_table = .{ + .ILGOCAEIFPF = fd(4, .{ .Varint = .Simple }), + .KJNKFJEBPAL = fd(13, .{ .List = .{ .SubMessage = {} } }), + .JAHBHEJKDPB = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FHJFPEPDKCH = struct { + BOBKEMCKNGK: ArrayList(GHALCPBJDPO), + OMGPDIPCAHE: u32 = 0, + DFOKGMPGEDB: bool = false, + MPODMDDEGJF: u32 = 0, + JPDJPPIOLEG: u32 = 0, + EFICNPDCKPK: u32 = 0, + OHNLLNNFOMD: bool = false, + NHAIFJDDBMM: u32 = 0, + + pub const _desc_table = .{ + .BOBKEMCKNGK = fd(6, .{ .List = .{ .SubMessage = {} } }), + .OMGPDIPCAHE = fd(9, .{ .Varint = .Simple }), + .DFOKGMPGEDB = fd(10, .{ .Varint = .Simple }), + .MPODMDDEGJF = fd(4, .{ .Varint = .Simple }), + .JPDJPPIOLEG = fd(7, .{ .Varint = .Simple }), + .EFICNPDCKPK = fd(5, .{ .Varint = .Simple }), + .OHNLLNNFOMD = fd(8, .{ .Varint = .Simple }), + .NHAIFJDDBMM = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPLKHACIIGE = struct { + JPDJPPIOLEG: u32 = 0, + + pub const _desc_table = .{ + .JPDJPPIOLEG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIHPOLPEDHF = struct { + JPDJPPIOLEG: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .JPDJPPIOLEG = fd(11, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMFDADFPCEF = struct { + JPDJPPIOLEG: u32 = 0, + EFICNPDCKPK: u32 = 0, + NHAIFJDDBMM: u32 = 0, + + pub const _desc_table = .{ + .JPDJPPIOLEG = fd(3, .{ .Varint = .Simple }), + .EFICNPDCKPK = fd(13, .{ .Varint = .Simple }), + .NHAIFJDDBMM = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGNHPGNNBGM = struct { + CPMMFIMHFFK: ?FHJFPEPDKCH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CPMMFIMHFFK = fd(8, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJMFBMJIGBA = struct { + JPDJPPIOLEG: u32 = 0, + + pub const _desc_table = .{ + .JPDJPPIOLEG = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JHAIBMHGEKA = struct { + retcode: u32 = 0, + OHNLLNNFOMD: bool = false, + JPDJPPIOLEG: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .OHNLLNNFOMD = fd(2, .{ .Varint = .Simple }), + .JPDJPPIOLEG = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJNFHCLJBKF = struct { + LBNNAIPOCMA: u32 = 0, + JPDJPPIOLEG: u32 = 0, + JAHBHEJKDPB: u32 = 0, + + pub const _desc_table = .{ + .LBNNAIPOCMA = fd(6, .{ .Varint = .Simple }), + .JPDJPPIOLEG = fd(10, .{ .Varint = .Simple }), + .JAHBHEJKDPB = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNNGFCCBHKB = struct { + CPMMFIMHFFK: ?FHJFPEPDKCH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CPMMFIMHFFK = fd(1, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BAADANDMFEK = struct { + JKHMBGGOKJA: ArrayList(FHJFPEPDKCH), + + pub const _desc_table = .{ + .JKHMBGGOKJA = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFPNLANBIPA = struct { + MGKDFNBENAI: u32 = 0, + phase: u32 = 0, + FGMLGNAIGPM: u32 = 0, + JKHMBGGOKJA: ArrayList(FHJFPEPDKCH), + + pub const _desc_table = .{ + .MGKDFNBENAI = fd(2, .{ .Varint = .Simple }), + .phase = fd(4, .{ .Varint = .Simple }), + .FGMLGNAIGPM = fd(6, .{ .Varint = .Simple }), + .JKHMBGGOKJA = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APBLBBAMFAF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BILPMGBMIEN = struct { + retcode: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .level = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNIOCKDADFK = struct { + skill_id: u32 = 0, + ABCABFMCNAL: u32 = 0, + + pub const _desc_table = .{ + .skill_id = fd(11, .{ .Varint = .Simple }), + .ABCABFMCNAL = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PGNMNAADNFK = struct { + event_id: u32 = 0, + avatar_id_list: ArrayList(u32), + skill_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(6, .{ .Varint = .Simple }), + .avatar_id_list = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .skill_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LEPLKABPMCF = struct { + battle_info: ?SceneBattleInfo = null, + event_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(3, .{ .SubMessage = {} }), + .event_id = fd(6, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAOKBEMJPNA = struct { + skill_id: u32 = 0, + + pub const _desc_table = .{ + .skill_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OGPEKOGIGEM = struct { + retcode: u32 = 0, + skill_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .skill_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGDBBIGOJFK = struct { + GHPNGHINJBH: ?IJEIKPEFCMI = null, + + pub const _desc_table = .{ + .GHPNGHINJBH = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFDFKBAJOHM = struct { + lineup: ?HeliobusChallengeLineup = null, + + pub const _desc_table = .{ + .lineup = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDHEOEDNONC = struct { + NGMKLNHPHEC: u32 = 0, + GGFPCDONOFJ: u32 = 0, + skill_id: u32 = 0, + prop_entity_id: u32 = 0, + avatar_list: ArrayList(u32), + HAPEGHIPNGA: bool = false, + + pub const _desc_table = .{ + .NGMKLNHPHEC = fd(13, .{ .Varint = .Simple }), + .GGFPCDONOFJ = fd(12, .{ .Varint = .Simple }), + .skill_id = fd(9, .{ .Varint = .Simple }), + .prop_entity_id = fd(3, .{ .Varint = .Simple }), + .avatar_list = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .HAPEGHIPNGA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKJCKGIDMEH = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMLCAKAFDEA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLLPHAJABGB = struct { + APAMKMIGAOP: u32 = 0, + HDHDLMJIFAO: bool = false, + OKMNCEFGIMF: u32 = 0, + level: u32 = 0, + rank: u32 = 0, + promotion: u32 = 0, + unique_id: u32 = 0, + exp: u32 = 0, + + pub const _desc_table = .{ + .APAMKMIGAOP = fd(14, .{ .Varint = .Simple }), + .HDHDLMJIFAO = fd(15, .{ .Varint = .Simple }), + .OKMNCEFGIMF = fd(4, .{ .Varint = .Simple }), + .level = fd(13, .{ .Varint = .Simple }), + .rank = fd(3, .{ .Varint = .Simple }), + .promotion = fd(1, .{ .Varint = .Simple }), + .unique_id = fd(6, .{ .Varint = .Simple }), + .exp = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DADJGGOCGJF = struct { + main_affix_id: u32 = 0, + unique_id: u32 = 0, + exp: u32 = 0, + OKMNCEFGIMF: u32 = 0, + sub_affix_list: ArrayList(RelicAffix), + NKOJPAAAMCI: bool = false, + HDHDLMJIFAO: bool = false, + APAMKMIGAOP: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .main_affix_id = fd(5, .{ .Varint = .Simple }), + .unique_id = fd(9, .{ .Varint = .Simple }), + .exp = fd(7, .{ .Varint = .Simple }), + .OKMNCEFGIMF = fd(10, .{ .Varint = .Simple }), + .sub_affix_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + .NKOJPAAAMCI = fd(11, .{ .Varint = .Simple }), + .HDHDLMJIFAO = fd(8, .{ .Varint = .Simple }), + .APAMKMIGAOP = fd(13, .{ .Varint = .Simple }), + .level = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJHMEKCHFDH = struct { + BEPOEAHIDMF: u64 = 0, + NHFGFOCFGCG: u32 = 0, + APAMKMIGAOP: u32 = 0, + + pub const _desc_table = .{ + .BEPOEAHIDMF = fd(2, .{ .Varint = .Simple }), + .NHFGFOCFGCG = fd(5, .{ .Varint = .Simple }), + .APAMKMIGAOP = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKKAKMDBGAD = struct { + APAMKMIGAOP: u32 = 0, + NHFGFOCFGCG: u32 = 0, + + pub const _desc_table = .{ + .APAMKMIGAOP = fd(1, .{ .Varint = .Simple }), + .NHFGFOCFGCG = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNBDEDJHHKP = struct { + NHFGFOCFGCG: u32 = 0, + BEPOEAHIDMF: u64 = 0, + APAMKMIGAOP: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(5, .{ .Varint = .Simple }), + .BEPOEAHIDMF = fd(7, .{ .Varint = .Simple }), + .APAMKMIGAOP = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKGLDLPALGO = struct { + MEHHHLONJDO: ArrayList(u32), + LJKCANIHCEP: ArrayList(DNBDEDJHHKP), + LNALMACDFMO: u32 = 0, + DLCOBFIGMMD: ArrayList(CJHMEKCHFDH), + equipment_list: ArrayList(LLLPHAJABGB), + retcode: u32 = 0, + LPEEKIJBNGD: ArrayList(DENLODKNFJE), + APEKBJACDDH: ArrayList(CJHMEKCHFDH), + ONAOICLDFNJ: ArrayList(u32), + relic_list: ArrayList(DADJGGOCGJF), + PKINOJIKMLF: ArrayList(PileItem), + NOGKOKELAKC: ArrayList(DNBDEDJHHKP), + AFAPMKPDNAK: ArrayList(GKKAKMDBGAD), + + pub const _desc_table = .{ + .MEHHHLONJDO = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .LJKCANIHCEP = fd(6, .{ .List = .{ .SubMessage = {} } }), + .LNALMACDFMO = fd(13, .{ .Varint = .Simple }), + .DLCOBFIGMMD = fd(10, .{ .List = .{ .SubMessage = {} } }), + .equipment_list = fd(14, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(7, .{ .Varint = .Simple }), + .LPEEKIJBNGD = fd(3, .{ .List = .{ .Varint = .Simple } }), + .APEKBJACDDH = fd(4, .{ .List = .{ .SubMessage = {} } }), + .ONAOICLDFNJ = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .relic_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + .PKINOJIKMLF = fd(5, .{ .List = .{ .SubMessage = {} } }), + .NOGKOKELAKC = fd(1, .{ .List = .{ .SubMessage = {} } }), + .AFAPMKPDNAK = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELBJAFOBENC = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + LIEMECDNPEL: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(14, .{ .SubMessage = {} }), + .LIEMECDNPEL = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENMMHLAGDBK = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NIHDIHGCDCD = struct { + ICNBPLAAPFF: ArrayList(u32), + LLEOGKEEEGL: bool = false, + + pub const _desc_table = .{ + .ICNBPLAAPFF = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .LLEOGKEEEGL = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CODCOCEDEBO = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKPKKMIKMKP = struct { + base_avatar_id: u32 = 0, + KFJJDCCKNOL: u32 = 0, + BFGGBHNINLK: AvatarType = @enumFromInt(0), + HGDCHHIENCC: u32 = 0, + LBDJNGPKPMN: bool = false, + IDONMCFMCBE: u32 = 0, + + pub const _desc_table = .{ + .base_avatar_id = fd(11, .{ .Varint = .Simple }), + .KFJJDCCKNOL = fd(10, .{ .Varint = .Simple }), + .BFGGBHNINLK = fd(8, .{ .Varint = .Simple }), + .HGDCHHIENCC = fd(15, .{ .Varint = .Simple }), + .LBDJNGPKPMN = fd(1, .{ .Varint = .Simple }), + .IDONMCFMCBE = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFIOBFHLDFL = struct { + KFJJDCCKNOL: u32 = 0, + PJBNAMACMBL: u32 = 0, + ANMKBJHMKGC: u64 = 0, + HGDCHHIENCC: u32 = 0, + retcode: u32 = 0, + LEKONDEJLFD: ?ItemList = null, + + pub const _desc_table = .{ + .KFJJDCCKNOL = fd(7, .{ .Varint = .Simple }), + .PJBNAMACMBL = fd(14, .{ .Varint = .Simple }), + .ANMKBJHMKGC = fd(10, .{ .Varint = .Simple }), + .HGDCHHIENCC = fd(9, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + .LEKONDEJLFD = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJMKLKGHCPO = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + LIEMECDNPEL: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(4, .{ .SubMessage = {} }), + .LIEMECDNPEL = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDOGFEKJENG = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDIFLEBIHIC = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + LIEMECDNPEL: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(1, .{ .SubMessage = {} }), + .LIEMECDNPEL = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GMJNIJIKEIM = struct { + DIFKMAGCOIG: ArrayList(PileItem), + retcode: u32 = 0, + + pub const _desc_table = .{ + .DIFKMAGCOIG = fd(10, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBPNHOELOAD = struct { + count: u32 = 0, + CAEAIHIDNIC: ?PEHCKCFABKB = null, + ECHHADJBNCP: u32 = 0, + + pub const _desc_table = .{ + .count = fd(4, .{ .Varint = .Simple }), + .CAEAIHIDNIC = fd(8, .{ .SubMessage = {} }), + .ECHHADJBNCP = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LANLMDDOLJJ = struct { + count: u32 = 0, + ECHHADJBNCP: u32 = 0, + DIFKMAGCOIG: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .count = fd(3, .{ .Varint = .Simple }), + .ECHHADJBNCP = fd(15, .{ .Varint = .Simple }), + .DIFKMAGCOIG = fd(14, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EALDGFAGIGP = struct { + CAEAIHIDNIC: ?PEHCKCFABKB = null, + IKCMDICMNHK: u32 = 0, + main_affix_id: u32 = 0, + count: u32 = 0, + ECHHADJBNCP: u32 = 0, + + pub const _desc_table = .{ + .CAEAIHIDNIC = fd(12, .{ .SubMessage = {} }), + .IKCMDICMNHK = fd(6, .{ .Varint = .Simple }), + .main_affix_id = fd(3, .{ .Varint = .Simple }), + .count = fd(7, .{ .Varint = .Simple }), + .ECHHADJBNCP = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKNMDHGPGDJ = struct { + DIFKMAGCOIG: ?ItemList = null, + ECHHADJBNCP: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DIFKMAGCOIG = fd(5, .{ .SubMessage = {} }), + .ECHHADJBNCP = fd(4, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAMCKIOKOII = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + IPALMPODPOF: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(13, .{ .SubMessage = {} }), + .IPALMPODPOF = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJCMAHCDBHN = struct { + DIFKMAGCOIG: ArrayList(PileItem), + retcode: u32 = 0, + + pub const _desc_table = .{ + .DIFKMAGCOIG = fd(6, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGBMMDNEBDB = struct { + LLEOGKEEEGL: bool = false, + IPALMPODPOF: u32 = 0, + KGBGNGLNGEG: bool = false, + PPEILLDOCBE: ArrayList(u32), + + pub const _desc_table = .{ + .LLEOGKEEEGL = fd(4, .{ .Varint = .Simple }), + .IPALMPODPOF = fd(6, .{ .Varint = .Simple }), + .KGBGNGLNGEG = fd(2, .{ .Varint = .Simple }), + .PPEILLDOCBE = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCCPPCDLACC = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHBEGOLFELK = struct { + IPALMPODPOF: u32 = 0, + ECDOLCCNGAI: bool = false, + PPEILLDOCBE: ArrayList(u32), + KGBGNGLNGEG: bool = false, + + pub const _desc_table = .{ + .IPALMPODPOF = fd(7, .{ .Varint = .Simple }), + .ECDOLCCNGAI = fd(9, .{ .Varint = .Simple }), + .PPEILLDOCBE = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .KGBGNGLNGEG = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNINLOMNJKC = struct { + ECDOLCCNGAI: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ECDOLCCNGAI = fd(15, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDMIIJGPEIC = struct { + MELEIHIDKOI: bool = false, + HFBKPOBHBIM: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .MELEIHIDKOI = fd(6, .{ .Varint = .Simple }), + .HFBKPOBHBIM = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FNDCMEOBEJB = struct { + retcode: u32 = 0, + DIFKMAGCOIG: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .DIFKMAGCOIG = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RechargeSuccNotify = struct { + month_card_outdate_time: u64 = 0, + channel_order_no: ManagedString = .Empty, + item_list: ?ItemList = null, + product_id: ManagedString = .Empty, + + pub const _desc_table = .{ + .month_card_outdate_time = fd(5, .{ .Varint = .Simple }), + .channel_order_no = fd(7, .String), + .item_list = fd(3, .{ .SubMessage = {} }), + .product_id = fd(8, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGNMACJELPF = struct { + NHFGFOCFGCG: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ExchangeHcoinScRsp = struct { + num: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .num = fd(4, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJPPOKDNDNA = struct { + PDIGONIOFGC: u32 = 0, + + pub const _desc_table = .{ + .PDIGONIOFGC = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCDBBFOCCLI = struct { + NCNDEAOLBKG: ArrayList(u32), + + pub const _desc_table = .{ + .NCNDEAOLBKG = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFBJKEFNDPL = struct { + NOGKOKELAKC: ArrayList(DNBDEDJHHKP), + retcode: u32 = 0, + + pub const _desc_table = .{ + .NOGKOKELAKC = fd(1, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JKMKIADKFJO = struct { + GCBLDBNEIDB: u32 = 0, + OABFCOCIPPG: u32 = 0, + + pub const _desc_table = .{ + .GCBLDBNEIDB = fd(12, .{ .Varint = .Simple }), + .OABFCOCIPPG = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFEOKEFKMJD = struct { + OJJENFAMGBJ: ArrayList(JKMKIADKFJO), + + pub const _desc_table = .{ + .OJJENFAMGBJ = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MACOPBFHEED = struct { + PIAILANOKMM: ?JKMKIADKFJO = null, + + pub const _desc_table = .{ + .PIAILANOKMM = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMJGENDOHPB = struct { + GBIEPAPENKJ: u32 = 0, + DJOAJNAHOKB: u32 = 0, + OFLJPFBFGLB: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(14, .{ .Varint = .Simple }), + .DJOAJNAHOKB = fd(5, .{ .Varint = .Simple }), + .OFLJPFBFGLB = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAFBEAJHPOF = struct { + retcode: u32 = 0, + OFLJPFBFGLB: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .OFLJPFBFGLB = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDPMENMIMNA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMNOFABEDOI = struct { + HOFKMEIMAPH: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .HOFKMEIMAPH = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNKAPOKBPLA = struct { + GBIEPAPENKJ: u32 = 0, + NDDPACJIAOK: bool = false, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(6, .{ .Varint = .Simple }), + .NDDPACJIAOK = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AHBLIGHIELH = struct { + NDDPACJIAOK: bool = false, + retcode: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .NDDPACJIAOK = fd(15, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMGCIFIJNAI = struct { + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOOCKGLNMIC = struct { + LPEEKIJBNGD: ArrayList(DENLODKNFJE), + MEHHHLONJDO: ArrayList(u32), + + pub const _desc_table = .{ + .LPEEKIJBNGD = fd(5, .{ .List = .{ .Varint = .Simple } }), + .MEHHHLONJDO = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFANMMHOOEB = struct { + DGLLJFNEMOK: DENLODKNFJE = @enumFromInt(0), + LNEKBEGKACP: bool = false, + + pub const _desc_table = .{ + .DGLLJFNEMOK = fd(6, .{ .Varint = .Simple }), + .LNEKBEGKACP = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOOIPEAMHEE = struct { + retcode: u32 = 0, + DGLLJFNEMOK: DENLODKNFJE = @enumFromInt(0), + LNEKBEGKACP: bool = false, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .DGLLJFNEMOK = fd(3, .{ .Varint = .Simple }), + .LNEKBEGKACP = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EGLHGDBANLO = struct { + OJNGMLGBCPG: bool = false, + JIADCEIBKBD: ArrayList(PileItem), + + pub const _desc_table = .{ + .OJNGMLGBCPG = fd(4, .{ .Varint = .Simple }), + .JIADCEIBKBD = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APHEKFPDGGE = struct { + HOGELAPKDCE: u32 = 0, + IMECDDMEHIA: u32 = 0, + ANHIGIEBAEP: u32 = 0, + + pub const _desc_table = .{ + .HOGELAPKDCE = fd(5, .{ .Varint = .Simple }), + .IMECDDMEHIA = fd(11, .{ .Varint = .Simple }), + .ANHIGIEBAEP = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNOILALLBJH = struct { + HOGELAPKDCE: u32 = 0, + EJANDKAFHIA: u32 = 0, + + pub const _desc_table = .{ + .HOGELAPKDCE = fd(6, .{ .Varint = .Simple }), + .EJANDKAFHIA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNOANMLHEJC = struct { + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIKDPPIGICK = struct { + PHMCLOMFGPI: ArrayList(APHEKFPDGGE), + KCKACNLCALD: bool = false, + KJCBAJBGOGB: ArrayList(APHEKFPDGGE), + FHCPDKHFIMF: ArrayList(MNOILALLBJH), + MHHNFAGHGOL: ArrayList(MNOILALLBJH), + avatar_id: u32 = 0, + LKIPBCDGDOB: ArrayList(MNOILALLBJH), + ODDMGMGLJHD: ArrayList(MNOILALLBJH), + retcode: u32 = 0, + + pub const _desc_table = .{ + .PHMCLOMFGPI = fd(14, .{ .List = .{ .SubMessage = {} } }), + .KCKACNLCALD = fd(3, .{ .Varint = .Simple }), + .KJCBAJBGOGB = fd(2, .{ .List = .{ .SubMessage = {} } }), + .FHCPDKHFIMF = fd(13, .{ .List = .{ .SubMessage = {} } }), + .MHHNFAGHGOL = fd(12, .{ .List = .{ .SubMessage = {} } }), + .avatar_id = fd(11, .{ .Varint = .Simple }), + .LKIPBCDGDOB = fd(15, .{ .List = .{ .SubMessage = {} } }), + .ODDMGMGLJHD = fd(4, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLCJAHCKPMP = struct { + HBODBGDOEOI: u32 = 0, + + pub const _desc_table = .{ + .HBODBGDOEOI = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIEKMLNAKBI = struct { + avatar_id_list: ArrayList(u32), + KCKACNLCALD: bool = false, + retcode: u32 = 0, + HBODBGDOEOI: u32 = 0, + + pub const _desc_table = .{ + .avatar_id_list = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .KCKACNLCALD = fd(1, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + .HBODBGDOEOI = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNGDNBIAAMC = struct { + OHOEGOAECGK: u32 = 0, + FBPPKGCGILB: bool = false, + + pub const _desc_table = .{ + .OHOEGOAECGK = fd(12, .{ .Varint = .Simple }), + .FBPPKGCGILB = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIHNBJLGBCG = struct { + IHPLGEBKNAD: ?HNGDNBIAAMC = null, + KFDOAHPKDMC: bool = false, + FMNIINNJNHG: ?BGHFGPJPKLE = null, + KFIMJFGJLMM: u32 = 0, + CGHGGHLOIBL: i64 = 0, + name: ManagedString = .Empty, + + pub const _desc_table = .{ + .IHPLGEBKNAD = fd(4, .{ .SubMessage = {} }), + .KFDOAHPKDMC = fd(11, .{ .Varint = .Simple }), + .FMNIINNJNHG = fd(7, .{ .SubMessage = {} }), + .KFIMJFGJLMM = fd(6, .{ .Varint = .Simple }), + .CGHGGHLOIBL = fd(9, .{ .Varint = .Simple }), + .name = fd(14, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEPBLDOIDLL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNJKKLHBJNI = struct { + AMHEKOKMPNF: ArrayList(OIHNBJLGBCG), + retcode: u32 = 0, + + pub const _desc_table = .{ + .AMHEKOKMPNF = fd(5, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLDFPKMNLOJ = struct { + KFDOAHPKDMC: bool = false, + KFIMJFGJLMM: u32 = 0, + name: ManagedString = .Empty, + FMNIINNJNHG: ?BGHFGPJPKLE = null, + IHPLGEBKNAD: ?HNGDNBIAAMC = null, + + pub const _desc_table = .{ + .KFDOAHPKDMC = fd(12, .{ .Varint = .Simple }), + .KFIMJFGJLMM = fd(7, .{ .Varint = .Simple }), + .name = fd(2, .String), + .FMNIINNJNHG = fd(4, .{ .SubMessage = {} }), + .IHPLGEBKNAD = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AMALEIJEKMD = struct { + retcode: u32 = 0, + GCFDAAMPMEB: ?OIHNBJLGBCG = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .GCFDAAMPMEB = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLJAMCEIOBC = struct { + KFIMJFGJLMM: u32 = 0, + name: ManagedString = .Empty, + IHPLGEBKNAD: ?HNGDNBIAAMC = null, + FMNIINNJNHG: ?BGHFGPJPKLE = null, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(13, .{ .Varint = .Simple }), + .name = fd(3, .String), + .IHPLGEBKNAD = fd(8, .{ .SubMessage = {} }), + .FMNIINNJNHG = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNJEFCLFHEE = struct { + KFIMJFGJLMM: u32 = 0, + retcode: u32 = 0, + CGHGGHLOIBL: i64 = 0, + name: ManagedString = .Empty, + IHPLGEBKNAD: ?HNGDNBIAAMC = null, + FMNIINNJNHG: ?BGHFGPJPKLE = null, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(1, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + .CGHGGHLOIBL = fd(12, .{ .Varint = .Simple }), + .name = fd(5, .String), + .IHPLGEBKNAD = fd(14, .{ .SubMessage = {} }), + .FMNIINNJNHG = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPHKLKJPAAK = struct { + LPHDLPDLDJG: ArrayList(u32), + KGBGNGLNGEG: bool = false, + + pub const _desc_table = .{ + .LPHDLPDLDJG = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .KGBGNGLNGEG = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANLKFCMKGNL = struct { + retcode: u32 = 0, + LPHDLPDLDJG: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .LPHDLPDLDJG = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EGAMPDGABKL = struct { + LPHDLPDLDJG: ArrayList(u32), + KGBGNGLNGEG: bool = false, + PDOFIIHOCFH: bool = false, + + pub const _desc_table = .{ + .LPHDLPDLDJG = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .KGBGNGLNGEG = fd(2, .{ .Varint = .Simple }), + .PDOFIIHOCFH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALNMJCBEEBF = struct { + LPHDLPDLDJG: ArrayList(u32), + retcode: u32 = 0, + PDOFIIHOCFH: bool = false, + + pub const _desc_table = .{ + .LPHDLPDLDJG = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(11, .{ .Varint = .Simple }), + .PDOFIIHOCFH = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIMGEGLOHOG = struct { + KFIMJFGJLMM: u32 = 0, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIAKMFBBGEE = struct { + id: u32 = 0, + MHNLLCCOKNB: bool = false, + group_id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(12, .{ .Varint = .Simple }), + .MHNLLCCOKNB = fd(5, .{ .Varint = .Simple }), + .group_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NIOPELPEBDC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OGJEPBMFMDN = struct { + CFIEJBMCFOJ: u32 = 0, + retcode: u32 = 0, + MCKKFNNFIPE: ArrayList(GIAKMFBBGEE), + + pub const _desc_table = .{ + .CFIEJBMCFOJ = fd(10, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .MCKKFNNFIPE = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADJOIGHGPBG = struct { + NDMLGKHDNPH: u32 = 0, + + pub const _desc_table = .{ + .NDMLGKHDNPH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNOILKBJMFA = struct { + NDMLGKHDNPH: u32 = 0, + CFIEJBMCFOJ: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NDMLGKHDNPH = fd(7, .{ .Varint = .Simple }), + .CFIEJBMCFOJ = fd(10, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KILDHEONFMC = struct { + EMDPMMJKHFI: ArrayList(u32), + + pub const _desc_table = .{ + .EMDPMMJKHFI = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAHCEDPLEDF = struct { + retcode: u32 = 0, + MCKKFNNFIPE: ArrayList(GIAKMFBBGEE), + NACNNPODDOA: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .MCKKFNNFIPE = fd(14, .{ .List = .{ .SubMessage = {} } }), + .NACNNPODDOA = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOIJGJJNHND = struct { + CMOKPCOGFCA: u32 = 0, + + pub const _desc_table = .{ + .CMOKPCOGFCA = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCGGIECBINP = struct { + retcode: u32 = 0, + CMOKPCOGFCA: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .CMOKPCOGFCA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHJLEMDJPCP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EPHILOFOHGG = struct { + stage_type: u32 = 0, + AEEFPICKBLC: u32 = 0, + + pub const _desc_table = .{ + .stage_type = fd(12, .{ .Varint = .Simple }), + .AEEFPICKBLC = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJAJFPIPFGH = struct { + retcode: u32 = 0, + HKPMPCLFMNG: ArrayList(EPHILOFOHGG), + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .HKPMPCLFMNG = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LineupAvatar = struct { + sp: ?SpProgress = null, + slot: u32 = 0, + satiety: u32 = 0, + id: u32 = 0, + hp: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .sp = fd(7, .{ .SubMessage = {} }), + .slot = fd(13, .{ .Varint = .Simple }), + .satiety = fd(9, .{ .Varint = .Simple }), + .id = fd(11, .{ .Varint = .Simple }), + .hp = fd(2, .{ .Varint = .Simple }), + .avatar_type = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LineupInfo = struct { + IHBCJPBEGHP: u32 = 0, + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + ABOLLMBDFJP: ArrayList(u32), + IDFBPEDNECA: ArrayList(u32), + NGGPHGPDMFD: ArrayList(u32), + avatar_list: ArrayList(LineupAvatar), + plane_id: u32 = 0, + name: ManagedString = .Empty, + BOCEAHMENHD: u32 = 0, + HPMGGECENEM: u32 = 0, + HGBHBGMMOKG: u32 = 0, + MPHBMFKKAAM: bool = false, + index: u32 = 0, + is_virtual: bool = false, + + pub const _desc_table = .{ + .IHBCJPBEGHP = fd(11, .{ .Varint = .Simple }), + .extra_lineup_type = fd(6, .{ .Varint = .Simple }), + .ABOLLMBDFJP = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .IDFBPEDNECA = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .NGGPHGPDMFD = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .plane_id = fd(3, .{ .Varint = .Simple }), + .name = fd(1, .String), + .BOCEAHMENHD = fd(12, .{ .Varint = .Simple }), + .HPMGGECENEM = fd(14, .{ .Varint = .Simple }), + .HGBHBGMMOKG = fd(4, .{ .Varint = .Simple }), + .MPHBMFKKAAM = fd(15, .{ .Varint = .Simple }), + .index = fd(7, .{ .Varint = .Simple }), + .is_virtual = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetCurLineupDataCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetCurLineupDataScRsp = struct { + lineup: ?LineupInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .lineup = fd(3, .{ .SubMessage = {} }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KANKNAEKLKP = struct { + index: u32 = 0, + base_avatar_id: u32 = 0, + is_virtual: bool = false, + slot: u32 = 0, + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + avatar_type: AvatarType = @enumFromInt(0), + plane_id: u32 = 0, + + pub const _desc_table = .{ + .index = fd(11, .{ .Varint = .Simple }), + .base_avatar_id = fd(12, .{ .Varint = .Simple }), + .is_virtual = fd(3, .{ .Varint = .Simple }), + .slot = fd(6, .{ .Varint = .Simple }), + .extra_lineup_type = fd(10, .{ .Varint = .Simple }), + .avatar_type = fd(7, .{ .Varint = .Simple }), + .plane_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPAHBBLFDNE = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJGDAEANOLF = struct { + index: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + plane_id: u32 = 0, + is_virtual: bool = false, + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + base_avatar_id: u32 = 0, + + pub const _desc_table = .{ + .index = fd(8, .{ .Varint = .Simple }), + .avatar_type = fd(12, .{ .Varint = .Simple }), + .plane_id = fd(15, .{ .Varint = .Simple }), + .is_virtual = fd(2, .{ .Varint = .Simple }), + .extra_lineup_type = fd(4, .{ .Varint = .Simple }), + .base_avatar_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GEFAGHOPOKD = struct { + retcode: u32 = 0, + base_avatar_id: u32 = 0, + KMFHKBBBMMO: bool = false, + plane_id: u32 = 0, + is_virtual: bool = false, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .base_avatar_id = fd(7, .{ .Varint = .Simple }), + .KMFHKBBBMMO = fd(6, .{ .Varint = .Simple }), + .plane_id = fd(15, .{ .Varint = .Simple }), + .is_virtual = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLHJONOKIHC = struct { + OPHHEMEKAHG: u32 = 0, + plane_id: u32 = 0, + IPJANIPLLFG: u32 = 0, + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + index: u32 = 0, + is_virtual: bool = false, + + pub const _desc_table = .{ + .OPHHEMEKAHG = fd(3, .{ .Varint = .Simple }), + .plane_id = fd(6, .{ .Varint = .Simple }), + .IPJANIPLLFG = fd(4, .{ .Varint = .Simple }), + .extra_lineup_type = fd(11, .{ .Varint = .Simple }), + .index = fd(7, .{ .Varint = .Simple }), + .is_virtual = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIMLLKNGLKP = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SyncLineupNotify = struct { + lineup: ?LineupInfo = null, + reason_list: ArrayList(SyncLineupReason), + + pub const _desc_table = .{ + .lineup = fd(13, .{ .SubMessage = {} }), + .reason_list = fd(1, .{ .List = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIHBPHBEOCI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAHAFEFPCPD = struct { + id: u32 = 0, + hp: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .id = fd(6, .{ .Varint = .Simple }), + .hp = fd(15, .{ .Varint = .Simple }), + .avatar_type = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEGOGJNEOMF = struct { + retcode: u32 = 0, + PJHCJIBEBAA: ArrayList(KAHAFEFPCPD), + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .PJHCJIBEBAA = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ChangeLineupLeaderCsReq = struct { + slot: u32 = 0, + + pub const _desc_table = .{ + .slot = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ChangeLineupLeaderScRsp = struct { + retcode: u32 = 0, + slot: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .slot = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLABCCJEKEJ = struct { + index: u32 = 0, + + pub const _desc_table = .{ + .index = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLBBOLNEOML = struct { + retcode: u32 = 0, + index: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .index = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetLineupNameCsReq = struct { + index: u32 = 0, + name: ManagedString = .Empty, + + pub const _desc_table = .{ + .index = fd(9, .{ .Varint = .Simple }), + .name = fd(2, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetLineupNameScRsp = struct { + name: ManagedString = .Empty, + retcode: u32 = 0, + index: u32 = 0, + + pub const _desc_table = .{ + .name = fd(8, .String), + .retcode = fd(5, .{ .Varint = .Simple }), + .index = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetAllLineupDataCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetAllLineupDataScRsp = struct { + retcode: u32 = 0, + lineup_list: ArrayList(LineupInfo), + cur_index: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .lineup_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .cur_index = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMIMFHIAGCG = struct { + plane_id: u32 = 0, + + pub const _desc_table = .{ + .plane_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMGGNKGPDCM = struct { + avatar_type: AvatarType = @enumFromInt(0), + id: u32 = 0, + slot: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(8, .{ .Varint = .Simple }), + .id = fd(5, .{ .Varint = .Simple }), + .slot = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPAGJPHJDBD = struct { + BOCEAHMENHD: u32 = 0, + plane_id: u32 = 0, + IHBCJPBEGHP: u32 = 0, + is_virtual: bool = false, + IPHNMDOIFON: ArrayList(OMGGNKGPDCM), + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + index: u32 = 0, + + pub const _desc_table = .{ + .BOCEAHMENHD = fd(12, .{ .Varint = .Simple }), + .plane_id = fd(3, .{ .Varint = .Simple }), + .IHBCJPBEGHP = fd(7, .{ .Varint = .Simple }), + .is_virtual = fd(4, .{ .Varint = .Simple }), + .IPHNMDOIFON = fd(14, .{ .List = .{ .SubMessage = {} } }), + .extra_lineup_type = fd(10, .{ .Varint = .Simple }), + .index = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLDNGOALCDB = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPFCEMJEFKA = struct { + extra_lineup_type: ExtraLineupType = @enumFromInt(0), + + pub const _desc_table = .{ + .extra_lineup_type = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEGIPGHOGDE = struct { + MHDJJGDLLIG: ?JBEBLKIKGMP = null, + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + + pub const _desc_table = .{ + .MHDJJGDLLIG = fd(10, .{ .SubMessage = {} }), + .MHCFIEHGNCE = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIDNLINDFPL = struct { + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + LOPNFDJHCLN: u64 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MHCFIEHGNCE = fd(6, .{ .Varint = .Simple }), + .DOLKBPLJGNO = fd(3, .{ .List = .{ .SubMessage = {} } }), + .LOPNFDJHCLN = fd(15, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPGDILBGFEA = struct { + NHLFDHHPBPE: ArrayList(u32), + + pub const _desc_table = .{ + .NHLFDHHPBPE = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAPHADFGJEI = struct { + retcode: u32 = 0, + NHLFDHHPBPE: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .NHLFDHHPBPE = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFFANOLHJDA = struct { + MHDJJGDLLIG: ?JBEBLKIKGMP = null, + LOPNFDJHCLN: u64 = 0, + + pub const _desc_table = .{ + .MHDJJGDLLIG = fd(14, .{ .SubMessage = {} }), + .LOPNFDJHCLN = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGMOIKBIALM = struct { + LOPNFDJHCLN: u64 = 0, + retcode: u32 = 0, + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + + pub const _desc_table = .{ + .LOPNFDJHCLN = fd(2, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + .DOLKBPLJGNO = fd(9, .{ .List = .{ .SubMessage = {} } }), + .MHCFIEHGNCE = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDGDOBFIHOA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBLFAGNNKLB = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHKIDDENNLJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCNIGMIKOMO = struct { + retcode: u32 = 0, + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .DOLKBPLJGNO = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOJCKPINBGJ = struct { + EEOLCCFMJFF: FPFECCNFJJL = @enumFromInt(0), + FMIJGJANHFI: u32 = 0, + MHDJJGDLLIG: ?JBEBLKIKGMP = null, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(8, .{ .Varint = .Simple }), + .FMIJGJANHFI = fd(9, .{ .Varint = .Simple }), + .MHDJJGDLLIG = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EAPJPCDAGDH = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDOKMKMNAEN = struct { + EEOLCCFMJFF: FPFECCNFJJL = @enumFromInt(0), + uid: u32 = 0, + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(4, .{ .Varint = .Simple }), + .uid = fd(1, .{ .Varint = .Simple }), + .DOLKBPLJGNO = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEBHAJEOEKG = struct { + uid: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHFHNIADCBI = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FNPLAICDJMO = struct { + LOPNFDJHCLN: u32 = 0, + IJIDAJHNCLN: u32 = 0, + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + + pub const _desc_table = .{ + .LOPNFDJHCLN = fd(10, .{ .Varint = .Simple }), + .IJIDAJHNCLN = fd(9, .{ .Varint = .Simple }), + .MHCFIEHGNCE = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDJGHEAJDBL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKGGKAAMDLB = struct { + ILGJLGKPDON: u64 = 0, + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + retcode: u32 = 0, + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + LOPNFDJHCLN: u64 = 0, + + pub const _desc_table = .{ + .ILGJLGKPDON = fd(12, .{ .Varint = .Simple }), + .MHCFIEHGNCE = fd(8, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + .DOLKBPLJGNO = fd(14, .{ .List = .{ .SubMessage = {} } }), + .LOPNFDJHCLN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECKHCKJMEDG = struct { + IHLFHFGHDLA: u32 = 0, + DHPNEGPDHFN: u32 = 0, + + pub const _desc_table = .{ + .IHLFHFGHDLA = fd(11, .{ .Varint = .Simple }), + .DHPNEGPDHFN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ClientMail = struct { + is_read: bool = false, + id: u32 = 0, + mail_type: FNAIBDHKPEI = @enumFromInt(0), + title: ManagedString = .Empty, + time: i64 = 0, + attachment: ?ItemList = null, + template_id: u32 = 0, + sender: ManagedString = .Empty, + expire_time: i64 = 0, + content: ManagedString = .Empty, + para_list: ArrayList(ManagedString), + + pub const _desc_table = .{ + .is_read = fd(4, .{ .Varint = .Simple }), + .id = fd(7, .{ .Varint = .Simple }), + .mail_type = fd(13, .{ .Varint = .Simple }), + .title = fd(8, .String), + .time = fd(6, .{ .Varint = .Simple }), + .attachment = fd(15, .{ .SubMessage = {} }), + .template_id = fd(5, .{ .Varint = .Simple }), + .sender = fd(9, .String), + .expire_time = fd(1, .{ .Varint = .Simple }), + .content = fd(10, .String), + .para_list = fd(3, .{ .List = .String }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetMailScRsp = struct { + start: u32 = 0, + mail_list: ArrayList(ClientMail), + total_num: u32 = 0, + is_end: bool = false, + retcode: u32 = 0, + notice_mail_list: ArrayList(ClientMail), + + pub const _desc_table = .{ + .start = fd(11, .{ .Varint = .Simple }), + .mail_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + .total_num = fd(7, .{ .Varint = .Simple }), + .is_end = fd(13, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .notice_mail_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMHKPAFPFHA = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CDBGOIFLJAF = struct { + id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .id = fd(6, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCLLIDBLIII = struct { + IJDPHIBNINI: ArrayList(u32), + + pub const _desc_table = .{ + .IJDPHIBNINI = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DelMailScRsp = struct { + id_list: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODMKMFJPJBM = struct { + IDONMCFMCBE: u32 = 0, + MJLDMHMHGNM: ArrayList(u32), + + pub const _desc_table = .{ + .IDONMCFMCBE = fd(12, .{ .Varint = .Simple }), + .MJLDMHMHGNM = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGFDCMBIGBE = struct { + BOEAIPLLHMB: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .BOEAIPLLHMB = fd(6, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const TakeMailAttachmentScRsp = struct { + fail_mail_list: ArrayList(GGFDCMBIGBE), + attachment: ?ItemList = null, + retcode: u32 = 0, + succ_mail_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .fail_mail_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + .attachment = fd(15, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + .succ_mail_id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NewMailScNotify = struct { + mail_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .mail_id_list = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADFICOFDKCG = struct { + OHCEDACENOC: ?OAKOJBOEMAA = null, + MPPILEKCMDP: i32 = 0, + KEEINILNFCI: ArrayList(KFGHDGMFPPL), + IJMNJKAKNDI: u32 = 0, + FOLHDJAICPG: ?HFGHBBKLDEF = null, + LADIFOHNBDH: bool = false, + LKHNIKBNFKA: ArrayList(LFKPNKEDDMG), + + pub const _desc_table = .{ + .OHCEDACENOC = fd(8, .{ .SubMessage = {} }), + .MPPILEKCMDP = fd(13, .{ .Varint = .Simple }), + .KEEINILNFCI = fd(1, .{ .List = .{ .SubMessage = {} } }), + .IJMNJKAKNDI = fd(10, .{ .Varint = .Simple }), + .FOLHDJAICPG = fd(4, .{ .SubMessage = {} }), + .LADIFOHNBDH = fd(6, .{ .Varint = .Simple }), + .LKHNIKBNFKA = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFGHBBKLDEF = struct { + CGBOKCHHEGG: u32 = 0, + MHBDEBNNLMG: u32 = 0, + + pub const _desc_table = .{ + .CGBOKCHHEGG = fd(14, .{ .Varint = .Simple }), + .MHBDEBNNLMG = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAKOJBOEMAA = struct { + PBPDGAMKBPM: ?Vector = null, + MJINOEJMBON: ?Quaternion = null, + + pub const _desc_table = .{ + .PBPDGAMKBPM = fd(11, .{ .SubMessage = {} }), + .MJINOEJMBON = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CCCDKENCIKF = struct { + MPPILEKCMDP: u32 = 0, + IJMNJKAKNDI: u32 = 0, + motion: ?MotionInfo = null, + + pub const _desc_table = .{ + .MPPILEKCMDP = fd(3, .{ .Varint = .Simple }), + .IJMNJKAKNDI = fd(6, .{ .Varint = .Simple }), + .motion = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GCLFFLBOJBM = struct { + interact_id: u32 = 0, + MPPILEKCMDP: u32 = 0, + retcode: u32 = 0, + FOLHDJAICPG: ?HFGHBBKLDEF = null, + motion: ?MotionInfo = null, + IJMNJKAKNDI: u32 = 0, + + pub const _desc_table = .{ + .interact_id = fd(15, .{ .Varint = .Simple }), + .MPPILEKCMDP = fd(11, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + .FOLHDJAICPG = fd(8, .{ .SubMessage = {} }), + .motion = fd(6, .{ .SubMessage = {} }), + .IJMNJKAKNDI = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFGHDGMFPPL = struct { + group_id: u32 = 0, + IOKBKAOEIPC: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(13, .{ .Varint = .Simple }), + .IOKBKAOEIPC = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBGDIIPOJOB = struct { + KBICCCPNMEN: ?KFGHDGMFPPL = null, + + pub const _desc_table = .{ + .KBICCCPNMEN = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMLHDAFMMOK = struct { + FOLHDJAICPG: ?HFGHBBKLDEF = null, + retcode: u32 = 0, + KBICCCPNMEN: ?KFGHDGMFPPL = null, + + pub const _desc_table = .{ + .FOLHDJAICPG = fd(13, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + .KBICCCPNMEN = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFKPNKEDDMG = struct { + ANIFKEGIHJM: f32 = 0, + IOKBKAOEIPC: u32 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .ANIFKEGIHJM = fd(1, .{ .FixedInt = .I32 }), + .IOKBKAOEIPC = fd(9, .{ .Varint = .Simple }), + .group_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLJAPENIJMD = struct { + FAFGOPMLOCJ: ?LFKPNKEDDMG = null, + + pub const _desc_table = .{ + .FAFGOPMLOCJ = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCHLLFCPKJF = struct { + FAFGOPMLOCJ: ?LFKPNKEDDMG = null, + FOLHDJAICPG: ?HFGHBBKLDEF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FAFGOPMLOCJ = fd(5, .{ .SubMessage = {} }), + .FOLHDJAICPG = fd(15, .{ .SubMessage = {} }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEHNGMEOOEP = struct { + group_id: u32 = 0, + IOKBKAOEIPC: u32 = 0, + OHCEDACENOC: ?OAKOJBOEMAA = null, + motion: ?MotionInfo = null, + + pub const _desc_table = .{ + .group_id = fd(8, .{ .Varint = .Simple }), + .IOKBKAOEIPC = fd(7, .{ .Varint = .Simple }), + .OHCEDACENOC = fd(3, .{ .SubMessage = {} }), + .motion = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEHAICJPFFO = struct { + interact_id: u32 = 0, + retcode: u32 = 0, + motion: ?MotionInfo = null, + + pub const _desc_table = .{ + .interact_id = fd(5, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + .motion = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFBNJAEDKLF = struct { + motion: ?MotionInfo = null, + + pub const _desc_table = .{ + .motion = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JKIGNNNHLKD = struct { + motion: ?MotionInfo = null, + interact_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .motion = fd(11, .{ .SubMessage = {} }), + .interact_id = fd(6, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCKKPGIBJEL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKOPLILBCPN = struct { + LKHNIKBNFKA: ArrayList(LFKPNKEDDMG), + IJMNJKAKNDI: u32 = 0, + retcode: u32 = 0, + KLOBDFKHJLJ: bool = false, + KEEINILNFCI: ArrayList(KFGHDGMFPPL), + MPPILEKCMDP: i32 = 0, + FOLHDJAICPG: ?HFGHBBKLDEF = null, + OHCEDACENOC: ?OAKOJBOEMAA = null, + + pub const _desc_table = .{ + .LKHNIKBNFKA = fd(1, .{ .List = .{ .SubMessage = {} } }), + .IJMNJKAKNDI = fd(3, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + .KLOBDFKHJLJ = fd(11, .{ .Varint = .Simple }), + .KEEINILNFCI = fd(5, .{ .List = .{ .SubMessage = {} } }), + .MPPILEKCMDP = fd(13, .{ .Varint = .Simple }), + .FOLHDJAICPG = fd(7, .{ .SubMessage = {} }), + .OHCEDACENOC = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DEKCGOPGOGJ = struct { + OHCEDACENOC: ?OAKOJBOEMAA = null, + motion: ?MotionInfo = null, + + pub const _desc_table = .{ + .OHCEDACENOC = fd(5, .{ .SubMessage = {} }), + .motion = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JAMMHLFCBNB = struct { + interact_id: u32 = 0, + motion: ?MotionInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .interact_id = fd(7, .{ .Varint = .Simple }), + .motion = fd(5, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGCJKHAFFCB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PFJBHHNHBCJ = struct { + FOLHDJAICPG: ?HFGHBBKLDEF = null, + + pub const _desc_table = .{ + .FOLHDJAICPG = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DDAIOKHMJMN = struct { + KLOBDFKHJLJ: bool = false, + KEEINILNFCI: ArrayList(KFGHDGMFPPL), + OHCEDACENOC: ?OAKOJBOEMAA = null, + IJMNJKAKNDI: u32 = 0, + FOLHDJAICPG: ?HFGHBBKLDEF = null, + LKHNIKBNFKA: ArrayList(LFKPNKEDDMG), + MPPILEKCMDP: i32 = 0, + + pub const _desc_table = .{ + .KLOBDFKHJLJ = fd(7, .{ .Varint = .Simple }), + .KEEINILNFCI = fd(12, .{ .List = .{ .SubMessage = {} } }), + .OHCEDACENOC = fd(5, .{ .SubMessage = {} }), + .IJMNJKAKNDI = fd(11, .{ .Varint = .Simple }), + .FOLHDJAICPG = fd(15, .{ .SubMessage = {} }), + .LKHNIKBNFKA = fd(10, .{ .List = .{ .SubMessage = {} } }), + .MPPILEKCMDP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HECJBLCHBJI = struct { + FAFGOPMLOCJ: ?LFKPNKEDDMG = null, + + pub const _desc_table = .{ + .FAFGOPMLOCJ = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJKCCPBIPCG = struct { + FOLHDJAICPG: ?HFGHBBKLDEF = null, + FAFGOPMLOCJ: ?LFKPNKEDDMG = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FOLHDJAICPG = fd(8, .{ .SubMessage = {} }), + .FAFGOPMLOCJ = fd(7, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJBMCNLGNPA = struct { + LKHNIKBNFKA: ArrayList(LFKPNKEDDMG), + + pub const _desc_table = .{ + .LKHNIKBNFKA = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BLBPLFADCOA = struct { + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + MHDJJGDLLIG: ?JBEBLKIKGMP = null, + + pub const _desc_table = .{ + .MHCFIEHGNCE = fd(15, .{ .Varint = .Simple }), + .MHDJJGDLLIG = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOHGDOONEDJ = struct { + MHDJJGDLLIG: ?JBEBLKIKGMP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MHDJJGDLLIG = fd(9, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOKHBPHIBAM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOHMBKPBMEC = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPBJJMPNBKB = struct { + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + retcode: u32 = 0, + + pub const _desc_table = .{ + .DOLKBPLJGNO = fd(6, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLHGMKAOKOL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGMFPCOBKCB = struct { + retcode: u32 = 0, + ILGJLGKPDON: u64 = 0, + MHCFIEHGNCE: HCKIOAEMKEE = @enumFromInt(0), + LOPNFDJHCLN: u64 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .ILGJLGKPDON = fd(10, .{ .Varint = .Simple }), + .MHCFIEHGNCE = fd(11, .{ .Varint = .Simple }), + .LOPNFDJHCLN = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPAHDBHINGA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILGPCLDJFOE = struct { + LAAFPDHGMBG: u32 = 0, + BGMAGGLPJNN: u32 = 0, + + pub const _desc_table = .{ + .LAAFPDHGMBG = fd(1, .{ .Varint = .Simple }), + .BGMAGGLPJNN = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEMNHLAPBOG = struct { + pos: u32 = 0, + JIELNNCBKOD: u32 = 0, + CPKLPJGGEOM: u32 = 0, + count: u32 = 0, + + pub const _desc_table = .{ + .pos = fd(11, .{ .Varint = .Simple }), + .JIELNNCBKOD = fd(10, .{ .Varint = .Simple }), + .CPKLPJGGEOM = fd(9, .{ .Varint = .Simple }), + .count = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLLPBIJLJIH = struct { + FFOLOOAGDEI: ArrayList(FEMNHLAPBOG), + PCKBGKDCHAB: ArrayList(PCKBGKDCHABEntry), + MIMOBNLKAPN: ArrayList(MIMOBNLKAPNEntry), + ODMDDNEJFBI: ArrayList(ILGPCLDJFOE), + + pub const _desc_table = .{ + .FFOLOOAGDEI = fd(11, .{ .List = .{ .SubMessage = {} } }), + .PCKBGKDCHAB = fd(1, .{ .List = .{ .SubMessage = {} } }), + .MIMOBNLKAPN = fd(7, .{ .List = .{ .SubMessage = {} } }), + .ODMDDNEJFBI = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const PCKBGKDCHABEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const MIMOBNLKAPNEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFNOHBLFEKM = struct { + retcode: u32 = 0, + OHHLIMNNEBB: ?JLLPBIJLJIH = null, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .OHHLIMNNEBB = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNPBFICBJPC = struct { + DHFDCMJDOGL: ArrayList(u32), + AJPBDPPHGHC: ManagedString = .Empty, + PCKBGKDCHAB: ArrayList(PCKBGKDCHABEntry), + JIELNNCBKOD: u32 = 0, + BGMAGGLPJNN: u32 = 0, + CPKLPJGGEOM: u32 = 0, + LAAFPDHGMBG: u32 = 0, + + pub const _desc_table = .{ + .DHFDCMJDOGL = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .AJPBDPPHGHC = fd(1, .String), + .PCKBGKDCHAB = fd(6, .{ .List = .{ .SubMessage = {} } }), + .JIELNNCBKOD = fd(11, .{ .Varint = .Simple }), + .BGMAGGLPJNN = fd(8, .{ .Varint = .Simple }), + .CPKLPJGGEOM = fd(14, .{ .Varint = .Simple }), + .LAAFPDHGMBG = fd(4, .{ .Varint = .Simple }), + }; + + pub const PCKBGKDCHABEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LOLOLPJDJFA = struct { + retcode: u32 = 0, + LAAFPDHGMBG: u32 = 0, + BGMAGGLPJNN: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .LAAFPDHGMBG = fd(13, .{ .Varint = .Simple }), + .BGMAGGLPJNN = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCHDOCLFCLE = struct { + OHHLIMNNEBB: ?JLLPBIJLJIH = null, + + pub const _desc_table = .{ + .OHHLIMNNEBB = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFJLGMGLHFF = struct { + pos: u32 = 0, + JIELNNCBKOD: u32 = 0, + + pub const _desc_table = .{ + .pos = fd(11, .{ .Varint = .Simple }), + .JIELNNCBKOD = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPELBAPMOAI = struct { + JIELNNCBKOD: u32 = 0, + retcode: u32 = 0, + pos: u32 = 0, + + pub const _desc_table = .{ + .JIELNNCBKOD = fd(6, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + .pos = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLBFNDMHNLB = struct { + FHOFPIEGJON: ArrayList(u32), + + pub const _desc_table = .{ + .FHOFPIEGJON = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IEKEDEPMJKB = struct { + OPFOGFNLLBE: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .OPFOGFNLLBE = fd(7, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLEHGOBEKJO = struct { + id: u32 = 0, + LEPDNAJCBPB: u32 = 0, + status: MessageSectionStatus = @enumFromInt(0), + DMBIDBENPGI: ArrayList(u32), + LHFFLOKIELE: ArrayList(IEKEDEPMJKB), + + pub const _desc_table = .{ + .id = fd(12, .{ .Varint = .Simple }), + .LEPDNAJCBPB = fd(5, .{ .Varint = .Simple }), + .status = fd(7, .{ .Varint = .Simple }), + .DMBIDBENPGI = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .LHFFLOKIELE = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFCDAEMFPKI = struct { + refresh_time: i64 = 0, + BPNFACHELGM: ArrayList(NLEHGOBEKJO), + id: u32 = 0, + KACIMADCGOI: u32 = 0, + status: MessageGroupStatus = @enumFromInt(0), + + pub const _desc_table = .{ + .refresh_time = fd(3, .{ .Varint = .Simple }), + .BPNFACHELGM = fd(15, .{ .List = .{ .SubMessage = {} } }), + .id = fd(12, .{ .Varint = .Simple }), + .KACIMADCGOI = fd(13, .{ .Varint = .Simple }), + .status = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPCHKAOCJJF = struct { + KIJLJOMDJEE: ArrayList(AFCDAEMFPKI), + retcode: u32 = 0, + + pub const _desc_table = .{ + .KIJLJOMDJEE = fd(5, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHONPAMNMGN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LEMMMGOFABH = struct { + npc_id: u32 = 0, + CHGPIDCCKEB: bool = false, + + pub const _desc_table = .{ + .npc_id = fd(15, .{ .Varint = .Simple }), + .CHGPIDCCKEB = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMBMCOPAKEJ = struct { + OFAPBILBJKM: MessageGroupStatus = @enumFromInt(0), + refresh_time: i64 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .OFAPBILBJKM = fd(10, .{ .Varint = .Simple }), + .refresh_time = fd(6, .{ .Varint = .Simple }), + .group_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEPMNFEENIB = struct { + CPBNHCCKFDG: MessageSectionStatus = @enumFromInt(0), + MANNEKNIHFO: u32 = 0, + + pub const _desc_table = .{ + .CPBNHCCKFDG = fd(11, .{ .Varint = .Simple }), + .MANNEKNIHFO = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMPIDJDGLAA = struct { + retcode: u32 = 0, + MDNMNNFMKGM: ArrayList(LEMMMGOFABH), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .MDNMNNFMKGM = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HMLKHHDFJKF = struct { + GBIEPAPENKJ: u32 = 0, + OPFOGFNLLBE: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(15, .{ .Varint = .Simple }), + .OPFOGFNLLBE = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGMGEEODNDJ = struct { + retcode: u32 = 0, + OPFOGFNLLBE: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .OPFOGFNLLBE = fd(11, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLGLBEIHOKD = struct { + MANNEKNIHFO: u32 = 0, + + pub const _desc_table = .{ + .MANNEKNIHFO = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLPCIDENIBJ = struct { + MANNEKNIHFO: u32 = 0, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .MANNEKNIHFO = fd(8, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNLLHKEPNKH = struct { + MANNEKNIHFO: u32 = 0, + LHFFLOKIELE: ArrayList(IEKEDEPMJKB), + + pub const _desc_table = .{ + .MANNEKNIHFO = fd(4, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMBCBCEBKMO = struct { + ADKJIIANOOM: ?ItemList = null, + LHFFLOKIELE: ArrayList(IEKEDEPMJKB), + MANNEKNIHFO: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(14, .{ .SubMessage = {} }), + .LHFFLOKIELE = fd(10, .{ .List = .{ .SubMessage = {} } }), + .MANNEKNIHFO = fd(5, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNLMKJLPLLA = struct { + IDEPHCKPNOA: u32 = 0, + + pub const _desc_table = .{ + .IDEPHCKPNOA = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJDCDGFLHKP = struct { + IDEPHCKPNOA: u32 = 0, + CICFPLGMOCJ: u32 = 0, + + pub const _desc_table = .{ + .IDEPHCKPNOA = fd(3, .{ .Varint = .Simple }), + .CICFPLGMOCJ = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCGCFEAAOAK = struct { + MBEKCOCEGFL: ?NJDCDGFLHKP = null, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .MBEKCOCEGFL = fd(12, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANCDKBINAFH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECLABJCPBLL = struct { + retcode: u32 = 0, + ICKOODFHDME: ArrayList(NJDCDGFLHKP), + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .ICKOODFHDME = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMICHHNGKKG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDKPCOEOBAB = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BLFDEEOAODH = struct { + MFGKKALDDIE: u32 = 0, + EEOLCCFMJFF: u32 = 0, + POCPPILNNOF: ArrayList(u32), + + pub const _desc_table = .{ + .MFGKKALDDIE = fd(2, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(10, .{ .Varint = .Simple }), + .POCPPILNNOF = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGKJAAHHNFO = struct { + KIIOMPIGDLK: ArrayList(BLFDEEOAODH), + + pub const _desc_table = .{ + .KIIOMPIGDLK = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMHHADPDABC = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FALAFLOMLAN = struct { + ADENLFJOOPL: ArrayList(u32), + LDELHKCCHHN: ArrayList(ManagedString), + EEOLCCFMJFF: HDCNOKOKDHC = @enumFromInt(0), + + pub const _desc_table = .{ + .ADENLFJOOPL = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .LDELHKCCHHN = fd(13, .{ .List = .String }), + .EEOLCCFMJFF = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMGEAKIDLHK = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCGFMHGCOLG = struct { + GBFDGCOPEDO: ManagedString = .Empty, + + pub const _desc_table = .{ + .GBFDGCOPEDO = fd(14, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAKPKHDNCFP = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJKNOBDPJAP = struct { + IGHBDHEBHAF: u32 = 0, + GAMGKLFHDAB: u32 = 0, + level: u32 = 0, + EEOLCCFMJFF: HBHPONEOFGF = @enumFromInt(0), + + pub const _desc_table = .{ + .IGHBDHEBHAF = fd(11, .{ .Varint = .Simple }), + .GAMGKLFHDAB = fd(3, .{ .Varint = .Simple }), + .level = fd(8, .{ .Varint = .Simple }), + .EEOLCCFMJFF = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENCELBGKOHA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKJGJDIOKBI = struct { + FNJMNKOGFIP: ArrayList(AJKNOBDPJAP), + retcode: u32 = 0, + + pub const _desc_table = .{ + .FNJMNKOGFIP = fd(14, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLIJGINANOH = struct { + BELMNMNPMNB: ?AJKNOBDPJAP = null, + + pub const _desc_table = .{ + .BELMNMNPMNB = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCJCIJGIEFI = struct { + retcode: u32 = 0, + BELMNMNPMNB: ?AJKNOBDPJAP = null, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .BELMNMNPMNB = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLKBEOPIOPN = struct { + HCILLIOMEEE: u32 = 0, + + pub const _desc_table = .{ + .HCILLIOMEEE = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KEIMGPMEDOG = struct { + HCILLIOMEEE: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .HCILLIOMEEE = fd(4, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGHCEKLHOKA = struct { + level: u32 = 0, + BHIDCAMHAPD: bool = false, + IPCOGHMEHLF: u32 = 0, + GAMGKLFHDAB: u32 = 0, + + pub const _desc_table = .{ + .level = fd(7, .{ .Varint = .Simple }), + .BHIDCAMHAPD = fd(4, .{ .Varint = .Simple }), + .IPCOGHMEHLF = fd(5, .{ .Varint = .Simple }), + .GAMGKLFHDAB = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIDCILFJOBL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHAOFNPDIIA = struct { + MKMLONGKIDC: ArrayList(LGHCEKLHOKA), + retcode: u32 = 0, + + pub const _desc_table = .{ + .MKMLONGKIDC = fd(7, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLEOKEMEPAE = struct { + AJPBDPPHGHC: u64 = 0, + group_id: u32 = 0, + KLKEEGFIGMB: ?LGHCEKLHOKA = null, + DMDLFLBPCHI: u32 = 0, + + pub const _desc_table = .{ + .AJPBDPPHGHC = fd(11, .{ .Varint = .Simple }), + .group_id = fd(5, .{ .Varint = .Simple }), + .KLKEEGFIGMB = fd(9, .{ .SubMessage = {} }), + .DMDLFLBPCHI = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDEBGNNLLMJ = struct { + KLKEEGFIGMB: ?LGHCEKLHOKA = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .KLKEEGFIGMB = fd(3, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGODCPNBPKM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMGGNJAKPGI = struct { + EEOLCCFMJFF: DHELEBHIKCD = @enumFromInt(0), + FJOJLFMCPKP: u32 = 0, + id: u32 = 0, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(8, .{ .Varint = .Simple }), + .FJOJLFMCPKP = fd(2, .{ .Varint = .Simple }), + .id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Mission = struct { + id: u32 = 0, + status: MissionStatus = @enumFromInt(0), + progress: u32 = 0, + + pub const _desc_table = .{ + .id = fd(2, .{ .Varint = .Simple }), + .status = fd(1, .{ .Varint = .Simple }), + .progress = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIAAMFMFBBE = struct { + index: u32 = 0, + JPBPMIKDLNB: u32 = 0, + + pub const _desc_table = .{ + .index = fd(15, .{ .Varint = .Simple }), + .JPBPMIKDLNB = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GEIJAMKJFEF = struct { + FMDHMHBPPEO: ArrayList(DIAAMFMFBBE), + + pub const _desc_table = .{ + .FMDHMHBPPEO = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LOOOCBGENKE = struct { + FMDHMHBPPEO: ArrayList(DIAAMFMFBBE), + status: MissionStatus = @enumFromInt(0), + id: u32 = 0, + + pub const _desc_table = .{ + .FMDHMHBPPEO = fd(9, .{ .List = .{ .SubMessage = {} } }), + .status = fd(15, .{ .Varint = .Simple }), + .id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOPEKIJOFFE = struct { + id: u32 = 0, + FMDHMHBPPEO: ?GEIJAMKJFEF = null, + + pub const _desc_table = .{ + .id = fd(1, .{ .Varint = .Simple }), + .FMDHMHBPPEO = fd(1080, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PACCCGPFMOF = struct { + FMDHMHBPPEO: ?GEIJAMKJFEF = null, + MELNHGLIDKJ: u32 = 0, + + pub const _desc_table = .{ + .FMDHMHBPPEO = fd(6, .{ .SubMessage = {} }), + .MELNHGLIDKJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANEGBGJOCCD = struct { + retcode: u32 = 0, + CNAFHGNLINI: bool = false, + CDHGCFEFDMO: ArrayList(Mission), + MDPFOGJCPEG: ArrayList(LOOOCBGENKE), + DPBAOFOMNGE: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .CNAFHGNLINI = fd(2, .{ .Varint = .Simple }), + .CDHGCFEFDMO = fd(11, .{ .List = .{ .SubMessage = {} } }), + .MDPFOGJCPEG = fd(9, .{ .List = .{ .SubMessage = {} } }), + .DPBAOFOMNGE = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MIOOAMNPMEB = struct { + MELNHGLIDKJ: u32 = 0, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAPECEHPLNM = struct { + retcode: u32 = 0, + MELNHGLIDKJ: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .MELNHGLIDKJ = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJCPFMBENFE = struct { + KMEAKPNGLMN: u32 = 0, + FMDHMHBPPEO: ArrayList(DIAAMFMFBBE), + AFGGGPNKGFO: ManagedString = .Empty, + + pub const _desc_table = .{ + .KMEAKPNGLMN = fd(15, .{ .Varint = .Simple }), + .FMDHMHBPPEO = fd(9, .{ .List = .{ .SubMessage = {} } }), + .AFGGGPNKGFO = fd(1, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JKDBMPFDJFM = struct { + FMDHMHBPPEO: ArrayList(DIAAMFMFBBE), + retcode: u32 = 0, + KMEAKPNGLMN: u32 = 0, + AFGGGPNKGFO: ManagedString = .Empty, + + pub const _desc_table = .{ + .FMDHMHBPPEO = fd(12, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(1, .{ .Varint = .Simple }), + .KMEAKPNGLMN = fd(13, .{ .Varint = .Simple }), + .AFGGGPNKGFO = fd(11, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EAPHKMIHDBP = struct { + MELNHGLIDKJ: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + KMEAKPNGLMN: u32 = 0, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(14, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(5, .{ .SubMessage = {} }), + .KMEAKPNGLMN = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IMCLACNFIEG = struct { + KMEAKPNGLMN: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .KMEAKPNGLMN = fd(14, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BELCBNIKAEE = struct { + MBBNDDLBEPE: ManagedString = .Empty, + + pub const _desc_table = .{ + .MBBNDDLBEPE = fd(11, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOFFHFJDMDN = struct { + MBBNDDLBEPE: ManagedString = .Empty, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MBBNDDLBEPE = fd(3, .String), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKLGJHMOMLH = struct { + MELNHGLIDKJ: u32 = 0, + FHMGJHNHAFM: bool = false, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(1, .{ .Varint = .Simple }), + .FHMGJHNHAFM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIPJLOHMNLH = struct { + KPHIGDGHHHL: u32 = 0, + GHFHEJAKJOF: ArrayList(PKLGJHMOMLH), + + pub const _desc_table = .{ + .KPHIGDGHHHL = fd(10, .{ .Varint = .Simple }), + .GHFHEJAKJOF = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKFJLCHKOAK = struct { + JKDPPIEENOH: ArrayList(u32), + + pub const _desc_table = .{ + .JKDPPIEENOH = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMAFBNPBFGL = struct { + KMEAKPNGLMN: u32 = 0, + LHFFLOKIELE: ?ItemList = null, + + pub const _desc_table = .{ + .KMEAKPNGLMN = fd(15, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BLDIFBMLGCG = struct { + retcode: u32 = 0, + KMEAKPNGLMN: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .KMEAKPNGLMN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAFBGDBNAKI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMMIAHIKOAE = struct { + MMAPHKJOECC: ArrayList(Mission), + DNOCIHOAIKH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MMAPHKJOECC = fd(15, .{ .List = .{ .SubMessage = {} } }), + .DNOCIHOAIKH = fd(7, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APGNFEAICCF = struct { + GBBNLGNNLEA: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .GBBNLGNNLEA = fd(2, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBMIOIMGLGG = struct { + GBBNLGNNLEA: u32 = 0, + + pub const _desc_table = .{ + .GBBNLGNNLEA = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHKDODNAAEN = struct { + DLEABJLBCMA: ?Mission = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DLEABJLBCMA = fd(1, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetMissionStatusCsReq = struct { + sub_mission_id_list: ArrayList(u32), + main_mission_id_list: ArrayList(u32), + mission_event_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .sub_mission_id_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .main_mission_id_list = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .mission_event_id_list = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetMissionStatusScRsp = struct { + main_mission_mcv_list: ArrayList(PACCCGPFMOF), + disabled_main_mission_id_list: ArrayList(u32), + retcode: u32 = 0, + mission_event_status_list: ArrayList(Mission), + finished_main_mission_id_list: ArrayList(u32), + sub_mission_status_list: ArrayList(Mission), + unfinished_main_mission_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .main_mission_mcv_list = fd(13, .{ .List = .{ .SubMessage = {} } }), + .disabled_main_mission_id_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(11, .{ .Varint = .Simple }), + .mission_event_status_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .finished_main_mission_id_list = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .sub_mission_status_list = fd(14, .{ .List = .{ .SubMessage = {} } }), + .unfinished_main_mission_id_list = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNBIKKFDJAD = struct { + GBBNLGNNLEA: u32 = 0, + + pub const _desc_table = .{ + .GBBNLGNNLEA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHLFGEACHHH = struct { + GBBNLGNNLEA: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GBBNLGNNLEA = fd(9, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POLNOPPCHFL = struct { + GBBNLGNNLEA: u32 = 0, + progress: u32 = 0, + + pub const _desc_table = .{ + .GBBNLGNNLEA = fd(3, .{ .Varint = .Simple }), + .progress = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBPKBAAKNLG = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEONJAAPJJF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EGPHKCNOFEI = struct { + interact_id: u32 = 0, + motion: ?MotionInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .interact_id = fd(3, .{ .Varint = .Simple }), + .motion = fd(14, .{ .SubMessage = {} }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJPNNDBAFBB = struct { + KMEAKPNGLMN: u32 = 0, + + pub const _desc_table = .{ + .KMEAKPNGLMN = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHNNDHNDHOM = struct { + MELNHGLIDKJ: u32 = 0, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOMOCKOCPGH = struct { + mission_event_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .mission_event_id_list = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LAGADAFJCNL = struct { + MDPFOGJCPEG: ArrayList(LOOOCBGENKE), + retcode: u32 = 0, + + pub const _desc_table = .{ + .MDPFOGJCPEG = fd(4, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGMJLIHNNMA = struct { + sub_mission_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .sub_mission_id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMGPMELLJLA = struct { + LAFFPEAFMCN: u32 = 0, + DPBAOFOMNGE: u32 = 0, + PDKNMDMMDJK: MOFOCPEAPDD = @enumFromInt(0), + + pub const _desc_table = .{ + .LAFFPEAFMCN = fd(7, .{ .Varint = .Simple }), + .DPBAOFOMNGE = fd(2, .{ .Varint = .Simple }), + .PDKNMDMMDJK = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOIDKKLKCFC = struct { + retcode: u32 = 0, + DPBAOFOMNGE: u32 = 0, + JANACOIJFMD: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .DPBAOFOMNGE = fd(13, .{ .Varint = .Simple }), + .JANACOIJFMD = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFODCGAHBHD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NILNKCMEFKO = struct { + FJJPPFKKCGD: bool = false, + EGONGOKNBGM: bool = false, + KPIKLIAODGG: u32 = 0, + CIPDPJPBAGD: u32 = 0, + CLCAABAPOFC: u32 = 0, + FOALCFHDEKA: u32 = 0, + + pub const _desc_table = .{ + .FJJPPFKKCGD = fd(5, .{ .Varint = .Simple }), + .EGONGOKNBGM = fd(7, .{ .Varint = .Simple }), + .KPIKLIAODGG = fd(3, .{ .Varint = .Simple }), + .CIPDPJPBAGD = fd(12, .{ .Varint = .Simple }), + .CLCAABAPOFC = fd(2, .{ .Varint = .Simple }), + .FOALCFHDEKA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPMNAAJDCGB = struct { + MKICOAABLKA: ArrayList(u32), + NIJHKNLKBKA: FBLFGOBDMKD = @enumFromInt(0), + + pub const _desc_table = .{ + .MKICOAABLKA = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .NIJHKNLKBKA = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGPNIEAKNED = struct { + CHMNKKJMBFI: u32 = 0, + progress: u32 = 0, + + pub const _desc_table = .{ + .CHMNKKJMBFI = fd(10, .{ .Varint = .Simple }), + .progress = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDNACICHLEA = struct { + HGOHNOMEPND: u64 = 0, + MBEDCLKGPEA: bool = false, + KENEMNBOOCB: bool = false, + + pub const _desc_table = .{ + .HGOHNOMEPND = fd(5, .{ .Varint = .Simple }), + .MBEDCLKGPEA = fd(8, .{ .Varint = .Simple }), + .KENEMNBOOCB = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POKGPJKKMGG = struct { + CLMPJAOHKCD: u32 = 0, + MEGDOBEGIPN: u64 = 0, + LECMBIOIENL: ManagedString = .Empty, + PGFLHACOLBG: ArrayList(NGPNIEAKNED), + PMALMJDGCIB: u64 = 0, + IENKLJIEAED: ArrayList(NGPNIEAKNED), + IDAEDOCPDID: u32 = 0, + JKCCELHBDNN: u32 = 0, + FANPKIMGLLG: ManagedString = .Empty, + KAJKPOHOPDO: ArrayList(NGPNIEAKNED), + HJFLFDPOGLB: ArrayList(LDNACICHLEA), + HINCOFBLIPO: u64 = 0, + BBHJPICGJJE: bool = false, + PGLPGNCJEEC: ArrayList(NGPNIEAKNED), + MHMCKHGJJPA: u32 = 0, + LECHMCAPHCF: u32 = 0, + KCHPOKNOMIA: u32 = 0, + HJLBKPMAHFA: ManagedString = .Empty, + + pub const _desc_table = .{ + .CLMPJAOHKCD = fd(4, .{ .Varint = .Simple }), + .MEGDOBEGIPN = fd(11, .{ .Varint = .Simple }), + .LECMBIOIENL = fd(257, .String), + .PGFLHACOLBG = fd(7, .{ .List = .{ .SubMessage = {} } }), + .PMALMJDGCIB = fd(14, .{ .Varint = .Simple }), + .IENKLJIEAED = fd(9, .{ .List = .{ .SubMessage = {} } }), + .IDAEDOCPDID = fd(5, .{ .Varint = .Simple }), + .JKCCELHBDNN = fd(2, .{ .Varint = .Simple }), + .FANPKIMGLLG = fd(242, .String), + .KAJKPOHOPDO = fd(1, .{ .List = .{ .SubMessage = {} } }), + .HJFLFDPOGLB = fd(13, .{ .List = .{ .SubMessage = {} } }), + .HINCOFBLIPO = fd(6, .{ .Varint = .Simple }), + .BBHJPICGJJE = fd(10, .{ .Varint = .Simple }), + .PGLPGNCJEEC = fd(12, .{ .List = .{ .SubMessage = {} } }), + .MHMCKHGJJPA = fd(8, .{ .Varint = .Simple }), + .LECHMCAPHCF = fd(15, .{ .Varint = .Simple }), + .KCHPOKNOMIA = fd(3, .{ .Varint = .Simple }), + .HJLBKPMAHFA = fd(850, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JIONFPDOKEH = struct { + OEDNDGOBHGE: ArrayList(POKGPJKKMGG), + + pub const _desc_table = .{ + .OEDNDGOBHGE = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKOBLOAHEHK = struct { + JJCJFNALGAD: ArrayList(u32), + retcode: u32 = 0, + LACNOCDMDEK: ?NFKOEBLKDBA = null, + PBCMIIENBFA: ?NILNKCMEFKO = null, + stt: ?IHBPFNOBGEM = null, + DMNEPHPOLEN: ?PANJFGJGLOL = null, + OHCEDACENOC: ?MKKFCGGHEPH = null, + DNNNDJCADJE: ?DLGMNAAKMKD = null, + NJHIOBCOLHM: ?HPMNAAJDCGB = null, + IIKIHCFKLJD: ?BJEHMMDMEGL = null, + PLDNMECDKIN: ?JIONFPDOKEH = null, + CJGJGEHNLFL: ?HDJLPNBNFPB = null, + PCABNBHKFHP: ?DNGGOODOCFE = null, + + pub const _desc_table = .{ + .JJCJFNALGAD = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(2, .{ .Varint = .Simple }), + .LACNOCDMDEK = fd(10, .{ .SubMessage = {} }), + .PBCMIIENBFA = fd(5, .{ .SubMessage = {} }), + .stt = fd(4, .{ .SubMessage = {} }), + .DMNEPHPOLEN = fd(12, .{ .SubMessage = {} }), + .OHCEDACENOC = fd(1, .{ .SubMessage = {} }), + .DNNNDJCADJE = fd(14, .{ .SubMessage = {} }), + .NJHIOBCOLHM = fd(7, .{ .SubMessage = {} }), + .IIKIHCFKLJD = fd(13, .{ .SubMessage = {} }), + .PLDNMECDKIN = fd(6, .{ .SubMessage = {} }), + .CJGJGEHNLFL = fd(11, .{ .SubMessage = {} }), + .PCABNBHKFHP = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJEHMMDMEGL = struct { + CBKHFFLMOKD: ArrayList(u32), + + pub const _desc_table = .{ + .CBKHFFLMOKD = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHGKBENJCLJ = struct { + IIKIHCFKLJD: ?BJEHMMDMEGL = null, + + pub const _desc_table = .{ + .IIKIHCFKLJD = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHBPFNOBGEM = struct { + BJADPDBPGFF: ArrayList(u32), + JCNAOCEBCAM: ArrayList(u32), + + pub const _desc_table = .{ + .BJADPDBPGFF = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .JCNAOCEBCAM = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOPLGHMAEKJ = struct { + stt: ?IHBPFNOBGEM = null, + + pub const _desc_table = .{ + .stt = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IMPCIBMECLB = struct { + ANMEDMEJHIO: bool = false, + JLJIKLDHIJE: u32 = 0, + EGKOJHEIOHH: u32 = 0, + AFEFKOFNIID: OAFMCJJFPHO = @enumFromInt(0), + + pub const _desc_table = .{ + .ANMEDMEJHIO = fd(8, .{ .Varint = .Simple }), + .JLJIKLDHIJE = fd(4, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(12, .{ .Varint = .Simple }), + .AFEFKOFNIID = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKKFCGGHEPH = struct { + PLOOMKKHLNF: ?IMPCIBMECLB = null, + FDMHKIIJDHD: ArrayList(IMPCIBMECLB), + GPBOAHHFKLF: ArrayList(IMPCIBMECLB), + CHBBMJPKIKN: u32 = 0, + KHDBGEHHFJL: u32 = 0, + + pub const _desc_table = .{ + .PLOOMKKHLNF = fd(10, .{ .SubMessage = {} }), + .FDMHKIIJDHD = fd(11, .{ .List = .{ .SubMessage = {} } }), + .GPBOAHHFKLF = fd(6, .{ .List = .{ .SubMessage = {} } }), + .CHBBMJPKIKN = fd(14, .{ .Varint = .Simple }), + .KHDBGEHHFJL = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OEALPKPNEDN = struct { + FDMHKIIJDHD: ArrayList(IMPCIBMECLB), + GPBOAHHFKLF: ArrayList(IMPCIBMECLB), + + pub const _desc_table = .{ + .FDMHKIIJDHD = fd(9, .{ .List = .{ .SubMessage = {} } }), + .GPBOAHHFKLF = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNOEPBPBADE = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEHEDCEICDE = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHGCBNHLGGN = struct { + MFNFDHAGAPH: u32 = 0, + MEDMIGPAMOG: u32 = 0, + DHEFOPIHAOG: ArrayList(u32), + event_id: u32 = 0, + + pub const _desc_table = .{ + .MFNFDHAGAPH = fd(15, .{ .Varint = .Simple }), + .MEDMIGPAMOG = fd(9, .{ .Varint = .Simple }), + .DHEFOPIHAOG = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .event_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMDKLNBLFMI = struct { + FEPNGGLIDPG: u32 = 0, + ICGFBEPBBNH: u32 = 0, + event_id: u32 = 0, + MEDMIGPAMOG: u32 = 0, + DHEFOPIHAOG: ArrayList(u32), + + pub const _desc_table = .{ + .FEPNGGLIDPG = fd(4, .{ .Varint = .Simple }), + .ICGFBEPBBNH = fd(8, .{ .Varint = .Simple }), + .event_id = fd(5, .{ .Varint = .Simple }), + .MEDMIGPAMOG = fd(7, .{ .Varint = .Simple }), + .DHEFOPIHAOG = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POHKGHPBLFB = struct { + KAHDDIKCDLC: u32 = 0, + NLKECKCDGEK: ArrayList(OKANJDMIODN), + + pub const _desc_table = .{ + .KAHDDIKCDLC = fd(14, .{ .Varint = .Simple }), + .NLKECKCDGEK = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCIHCFHIJEN = struct { + DCHFAONOOKK: u32 = 0, + + pub const _desc_table = .{ + .DCHFAONOOKK = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMBOMDFAMEM = struct { + OJCFOBHCBHK: u32 = 0, + + pub const _desc_table = .{ + .OJCFOBHCBHK = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCIPLPHHHJC = struct { + PFNFHAFOCGB: u32 = 0, + + pub const _desc_table = .{ + .PFNFHAFOCGB = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHECMAAPOJC = struct { + EAIFLKDLGKB: u32 = 0, + GEJIEPKHCKN: u32 = 0, + + pub const _desc_table = .{ + .EAIFLKDLGKB = fd(11, .{ .Varint = .Simple }), + .GEJIEPKHCKN = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKANJDMIODN = struct { + NBHPDMDNDKL: u32 = 0, + OGEPOCCCEBK: ?JNOEPBPBADE = null, + MJFDOAHFAAF: ?CEHEDCEICDE = null, + JOANGDLCHKM: ?HHGCBNHLGGN = null, + NOIFOCJDLGC: ?LCIHCFHIJEN = null, + FOHJOGGFIII: ?KMBOMDFAMEM = null, + DAPAKMMMAOJ: ?LCIPLPHHHJC = null, + KGDCAADCEOJ: ?CHECMAAPOJC = null, + DLDADINBFNF: ?PMDKLNBLFMI = null, + ADDNICELMIC: ?POHKGHPBLFB = null, + + pub const _desc_table = .{ + .NBHPDMDNDKL = fd(9, .{ .Varint = .Simple }), + .OGEPOCCCEBK = fd(7, .{ .SubMessage = {} }), + .MJFDOAHFAAF = fd(1, .{ .SubMessage = {} }), + .JOANGDLCHKM = fd(4, .{ .SubMessage = {} }), + .NOIFOCJDLGC = fd(10, .{ .SubMessage = {} }), + .FOHJOGGFIII = fd(6, .{ .SubMessage = {} }), + .DAPAKMMMAOJ = fd(12, .{ .SubMessage = {} }), + .KGDCAADCEOJ = fd(2, .{ .SubMessage = {} }), + .DLDADINBFNF = fd(8, .{ .SubMessage = {} }), + .ADDNICELMIC = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNGGOODOCFE = struct { + KIPOFIACOJG: ?OKANJDMIODN = null, + + pub const _desc_table = .{ + .KIPOFIACOJG = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBALHFEJEPP = struct { + KIPOFIACOJG: ?OKANJDMIODN = null, + + pub const _desc_table = .{ + .KIPOFIACOJG = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPIANHIGDHG = struct { + PLOOMKKHLNF: ?IMPCIBMECLB = null, + + pub const _desc_table = .{ + .PLOOMKKHLNF = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBEPJAODPFM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AILOCBNNPAE = struct { + retcode: u32 = 0, + HPGNFLGOKHP: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .HPGNFLGOKHP = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGDDBPOFFHF = struct { + LLAAIDOKNKD: u32 = 0, + + pub const _desc_table = .{ + .LLAAIDOKNKD = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LKDEKMGGKHE = struct { + LLAAIDOKNKD: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LLAAIDOKNKD = fd(7, .{ .Varint = .Simple }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PFPKNNMBJOC = struct { + OCDHHBLMICK: u32 = 0, + KCNKFFKLKJE: u32 = 0, + + pub const _desc_table = .{ + .OCDHHBLMICK = fd(1, .{ .Varint = .Simple }), + .KCNKFFKLKJE = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENPAHEICIAF = struct { + LCPNADPGLJI: ArrayList(IMPCIBMECLB), + OHCEDACENOC: ?MKKFCGGHEPH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LCPNADPGLJI = fd(13, .{ .List = .{ .SubMessage = {} } }), + .OHCEDACENOC = fd(5, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHHGAEPACFI = struct { + event_id: u32 = 0, + MFNFDHAGAPH: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(13, .{ .Varint = .Simple }), + .MFNFDHAGAPH = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMLKGHLGIBI = struct { + OHIFMOFFLDJ: u32 = 0, + event_id: u32 = 0, + MFNFDHAGAPH: u32 = 0, + + pub const _desc_table = .{ + .OHIFMOFFLDJ = fd(9, .{ .Varint = .Simple }), + .event_id = fd(5, .{ .Varint = .Simple }), + .MFNFDHAGAPH = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLCLFAHCGMF = struct { + MFNFDHAGAPH: u32 = 0, + retcode: u32 = 0, + PCABNBHKFHP: ?OKANJDMIODN = null, + event_id: u32 = 0, + EMKNBMDJALN: ArrayList(JMLKGHLGIBI), + + pub const _desc_table = .{ + .MFNFDHAGAPH = fd(13, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .PCABNBHKFHP = fd(5, .{ .SubMessage = {} }), + .event_id = fd(1, .{ .Varint = .Simple }), + .EMKNBMDJALN = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLNHNGIJPMB = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKFIPJAEMML = struct { + retcode: u32 = 0, + event_id: u32 = 0, + PCABNBHKFHP: ?OKANJDMIODN = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .event_id = fd(9, .{ .Varint = .Simple }), + .PCABNBHKFHP = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFDFEMPOAAC = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFHNOOPBAMB = struct { + event_id: u32 = 0, + retcode: u32 = 0, + PCABNBHKFHP: ?OKANJDMIODN = null, + + pub const _desc_table = .{ + .event_id = fd(5, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .PCABNBHKFHP = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJPIKAGGICK = struct { + event_id: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLFEPCLAOCB = struct { + PCABNBHKFHP: ?OKANJDMIODN = null, + retcode: u32 = 0, + event_id: u32 = 0, + + pub const _desc_table = .{ + .PCABNBHKFHP = fd(2, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + .event_id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNGOCPPKEDF = struct { + OJCFOBHCBHK: u32 = 0, + AALFIHNDABH: u32 = 0, + + pub const _desc_table = .{ + .OJCFOBHCBHK = fd(5, .{ .Varint = .Simple }), + .AALFIHNDABH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JFJBNCOJFMJ = struct { + OJCFOBHCBHK: u32 = 0, + AALFIHNDABH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .OJCFOBHCBHK = fd(10, .{ .Varint = .Simple }), + .AALFIHNDABH = fd(5, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJPLOFPIGGD = struct { + DCHFAONOOKK: u32 = 0, + + pub const _desc_table = .{ + .DCHFAONOOKK = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJCPJEJAHMD = struct { + DCHFAONOOKK: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DCHFAONOOKK = fd(3, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IDKJDGMNAPN = struct { + GMIGBLFHHAO: u32 = 0, + + pub const _desc_table = .{ + .GMIGBLFHHAO = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNHMJCIBAFG = struct { + GMIGBLFHHAO: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GMIGBLFHHAO = fd(1, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MonopolyActionResult = struct { + effect_type: u32 = 0, + trigger_cell_id: u32 = 0, + ClickCellId: u32 = 0, + click_map_id: u32 = 0, + trigger_map_id: u32 = 0, + source_type: BHGKIJGANCM = @enumFromInt(0), + detail: ?DBHLDAELOFI = null, + + pub const _desc_table = .{ + .effect_type = fd(4, .{ .Varint = .Simple }), + .trigger_cell_id = fd(15, .{ .Varint = .Simple }), + .ClickCellId = fd(8, .{ .Varint = .Simple }), + .click_map_id = fd(11, .{ .Varint = .Simple }), + .trigger_map_id = fd(10, .{ .Varint = .Simple }), + .source_type = fd(3, .{ .Varint = .Simple }), + .detail = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFEFLAEMDKM = struct { + LAIPBCKHEAJ: ArrayList(MonopolyActionResult), + + pub const _desc_table = .{ + .LAIPBCKHEAJ = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LODICMJKDON = struct { + AEEMNHEPMPM: bool = false, + IIBOMHINANG: u32 = 0, + + pub const _desc_table = .{ + .AEEMNHEPMPM = fd(8, .{ .Varint = .Simple }), + .IIBOMHINANG = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBHLDAELOFI = struct { + COOJHFNEOIP: ?ODPLDIICIBB = null, + MOBAJEJDEIJ: ?ODPLDIICIBB = null, + CFMNLCPLNBH: ?MGLFIDHLBPB = null, + NLAOOCOLJAC: ?MGLFIDHLBPB = null, + FIFIACFLFDL: ?NOBNJOEHEKP = null, + AGMHGBGGGFN: ?NOBNJOEHEKP = null, + FGDAHHOHGPE: ?AGMCNKBLLIA = null, + FNDIMEGKCLF: ?AGMCNKBLLIA = null, + FIHODDCBEGN: ?LODICMJKDON = null, + AFPOBALAEGK: ?OBFKMALBGML = null, + OGLIHGHLOFC: ?NOBNJOEHEKP = null, + IGOLGKPIJMN: ?AGMCNKBLLIA = null, + JCLKFJPCJNI: ?EKDKDGBMDDE = null, + + pub const _desc_table = .{ + .COOJHFNEOIP = fd(12, .{ .SubMessage = {} }), + .MOBAJEJDEIJ = fd(11, .{ .SubMessage = {} }), + .CFMNLCPLNBH = fd(2, .{ .SubMessage = {} }), + .NLAOOCOLJAC = fd(7, .{ .SubMessage = {} }), + .FIFIACFLFDL = fd(6, .{ .SubMessage = {} }), + .AGMHGBGGGFN = fd(3, .{ .SubMessage = {} }), + .FGDAHHOHGPE = fd(10, .{ .SubMessage = {} }), + .FNDIMEGKCLF = fd(13, .{ .SubMessage = {} }), + .FIHODDCBEGN = fd(15, .{ .SubMessage = {} }), + .AFPOBALAEGK = fd(5, .{ .SubMessage = {} }), + .OGLIHGHLOFC = fd(4, .{ .SubMessage = {} }), + .IGOLGKPIJMN = fd(1, .{ .SubMessage = {} }), + .JCLKFJPCJNI = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EKDKDGBMDDE = struct { + ODEPLBACIPG: u32 = 0, + + pub const _desc_table = .{ + .ODEPLBACIPG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODPLDIICIBB = struct { + PJHIPNNJDDP: u32 = 0, + GBIEPAPENKJ: u32 = 0, + ILGEENMAONM: u32 = 0, + + pub const _desc_table = .{ + .PJHIPNNJDDP = fd(7, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(14, .{ .Varint = .Simple }), + .ILGEENMAONM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGMCNKBLLIA = struct { + IPGCDNPGCOC: u32 = 0, + HCOCMPOIODB: u32 = 0, + + pub const _desc_table = .{ + .IPGCDNPGCOC = fd(7, .{ .Varint = .Simple }), + .HCOCMPOIODB = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBFKMALBGML = struct { + FIDCCOAADCP: u32 = 0, + DJBJKBEMKMD: u32 = 0, + OAOKDFJPPDN: u32 = 0, + KDPKIILLCDC: u32 = 0, + + pub const _desc_table = .{ + .FIDCCOAADCP = fd(7, .{ .Varint = .Simple }), + .DJBJKBEMKMD = fd(15, .{ .Varint = .Simple }), + .OAOKDFJPPDN = fd(3, .{ .Varint = .Simple }), + .KDPKIILLCDC = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOPOBJKCKFD = struct { + AAKIGJLJDHJ: u32 = 0, + DGFLHAEFBEP: u32 = 0, + LLKDIMANDCH: u32 = 0, + HPNKHMPIDKI: ?OPIMJFDHBEE = null, + EBPMCIHJLNP: ?IAGKOOPHPBM = null, + IFFFOCLOCGP: ?EJMONFLFDJK = null, + + pub const _desc_table = .{ + .AAKIGJLJDHJ = fd(5, .{ .Varint = .Simple }), + .DGFLHAEFBEP = fd(4, .{ .Varint = .Simple }), + .LLKDIMANDCH = fd(9, .{ .Varint = .Simple }), + .HPNKHMPIDKI = fd(14, .{ .SubMessage = {} }), + .EBPMCIHJLNP = fd(6, .{ .SubMessage = {} }), + .IFFFOCLOCGP = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDJLPNBNFPB = struct { + IHNBOAADOAP: ?IOPOBJKCKFD = null, + NOPIFJOBMMM: ArrayList(IOPOBJKCKFD), + DEHFEBKEINJ: ?LODICMJKDON = null, + + pub const _desc_table = .{ + .IHNBOAADOAP = fd(8, .{ .SubMessage = {} }), + .NOPIFJOBMMM = fd(7, .{ .List = .{ .SubMessage = {} } }), + .DEHFEBKEINJ = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIIOJKNELDP = struct { + DAPAKMMMAOJ: ?IOPOBJKCKFD = null, + DKJFFIDICLP: ?ItemList = null, + LHFFLOKIELE: ?ItemList = null, + + pub const _desc_table = .{ + .DAPAKMMMAOJ = fd(13, .{ .SubMessage = {} }), + .DKJFFIDICLP = fd(15, .{ .SubMessage = {} }), + .LHFFLOKIELE = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKEDELNHLCH = struct { + DAPAKMMMAOJ: ?IOPOBJKCKFD = null, + DEHFEBKEINJ: ?LODICMJKDON = null, + + pub const _desc_table = .{ + .DAPAKMMMAOJ = fd(12, .{ .SubMessage = {} }), + .DEHFEBKEINJ = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAAMJPMMKBI = struct { + LLKDIMANDCH: u32 = 0, + + pub const _desc_table = .{ + .LLKDIMANDCH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MonopolyGameRaiseRatioScRsp = struct { + retcode: u32 = 0, + ratio: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .ratio = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEMKBGFAAJB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMIBPLIBPHJ = struct { + LACNOCDMDEK: ?NFKOEBLKDBA = null, + PLABPPOECFN: i64 = 0, + EIHPANJOLAL: u32 = 0, + retcode: u32 = 0, + EFJMENDDMFB: bool = false, + + pub const _desc_table = .{ + .LACNOCDMDEK = fd(15, .{ .SubMessage = {} }), + .PLABPPOECFN = fd(1, .{ .Varint = .Simple }), + .EIHPANJOLAL = fd(2, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + .EFJMENDDMFB = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGOBHFPJBLD = struct { + OJNEMABFOND: bool = false, + + pub const _desc_table = .{ + .OJNEMABFOND = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GMMDGELHOHN = struct { + LPOKPLLNHPE: u32 = 0, + HCIBLLAPPMG: u32 = 0, + PLABPPOECFN: i64 = 0, + retcode: u32 = 0, + KBPCANEJHKO: u32 = 0, + AFIMBFONAHC: u32 = 0, + HAHCADMIMHJ: u32 = 0, + + pub const _desc_table = .{ + .LPOKPLLNHPE = fd(12, .{ .Varint = .Simple }), + .HCIBLLAPPMG = fd(1, .{ .Varint = .Simple }), + .PLABPPOECFN = fd(11, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + .KBPCANEJHKO = fd(8, .{ .Varint = .Simple }), + .AFIMBFONAHC = fd(6, .{ .Varint = .Simple }), + .HAHCADMIMHJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPIMJFDHBEE = struct { + GBOENJADPHH: ArrayList(u32), + HLCDCHJEDGJ: ArrayList(u32), + OFIIHECDNIE: ArrayList(u32), + JNHKGFPFJND: bool = false, + OCKFFMAIOMM: u32 = 0, + + pub const _desc_table = .{ + .GBOENJADPHH = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .HLCDCHJEDGJ = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .OFIIHECDNIE = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .JNHKGFPFJND = fd(11, .{ .Varint = .Simple }), + .OCKFFMAIOMM = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDMGLPFGCNB = struct { + MPCOPLEGPAJ: u32 = 0, + + pub const _desc_table = .{ + .MPCOPLEGPAJ = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EEDLJALOBGF = struct { + retcode: u32 = 0, + BABGDLHDFHE: u32 = 0, + HLCDCHJEDGJ: ArrayList(u32), + JNHKGFPFJND: bool = false, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .BABGDLHDFHE = fd(2, .{ .Varint = .Simple }), + .HLCDCHJEDGJ = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .JNHKGFPFJND = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPMGDHOFFPH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MonopolyGameGachaScRsp = struct { + retcode: u32 = 0, + result_list: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .result_list = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POEFIHFNHLF = struct { + OKMJKLAKGGE: u32 = 0, + BGEEAPCGEEA: u32 = 0, + + pub const _desc_table = .{ + .OKMJKLAKGGE = fd(8, .{ .Varint = .Simple }), + .BGEEAPCGEEA = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IAGKOOPHPBM = struct { + FPLEMJECNAM: u32 = 0, + KGMONFODKJO: ArrayList(u32), + GPHKPJAMMDO: u32 = 0, + MCPPPDDKPFO: ArrayList(POEFIHFNHLF), + ADIKGOLCKMC: u32 = 0, + HLJGPLCBLIP: u32 = 0, + + pub const _desc_table = .{ + .FPLEMJECNAM = fd(15, .{ .Varint = .Simple }), + .KGMONFODKJO = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .GPHKPJAMMDO = fd(9, .{ .Varint = .Simple }), + .MCPPPDDKPFO = fd(5, .{ .List = .{ .SubMessage = {} } }), + .ADIKGOLCKMC = fd(1, .{ .Varint = .Simple }), + .HLJGPLCBLIP = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFJBLGDINCC = struct { + MCPPPDDKPFO: ArrayList(POEFIHFNHLF), + + pub const _desc_table = .{ + .MCPPPDDKPFO = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOLLNKGNGHH = struct { + EBPMCIHJLNP: ?IAGKOOPHPBM = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EBPMCIHJLNP = fd(15, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNJPOEICAAE = struct { + GPHKPJAMMDO: u32 = 0, + BKHCGOJMEDE: u32 = 0, + CDDCLFCPCIO: u32 = 0, + + pub const _desc_table = .{ + .GPHKPJAMMDO = fd(12, .{ .Varint = .Simple }), + .BKHCGOJMEDE = fd(8, .{ .Varint = .Simple }), + .CDDCLFCPCIO = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFNECGOEPGM = struct { + IPHCFMPAMNF: ArrayList(PNJPOEICAAE), + + pub const _desc_table = .{ + .IPHCFMPAMNF = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EJMONFLFDJK = struct { + LGFFFIBLEND: bool = false, + EBEDDNGCLAH: u32 = 0, + CKNLGFBJDNM: u32 = 0, + + pub const _desc_table = .{ + .LGFFFIBLEND = fd(11, .{ .Varint = .Simple }), + .EBEDDNGCLAH = fd(3, .{ .Varint = .Simple }), + .CKNLGFBJDNM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLJJBPKMHMJ = struct { + CKNLGFBJDNM: u32 = 0, + + pub const _desc_table = .{ + .CKNLGFBJDNM = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KIMGABMCLEA = struct { + CKNLGFBJDNM: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CKNLGFBJDNM = fd(5, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIEKDBJOCKI = struct { + EBEDDNGCLAH: u32 = 0, + OBLFLDEJLNC: u32 = 0, + LHFFLOKIELE: ?ItemList = null, + + pub const _desc_table = .{ + .EBEDDNGCLAH = fd(15, .{ .Varint = .Simple }), + .OBLFLDEJLNC = fd(14, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLELHJMJJFC = struct { + PDAAJEDAIMG: ArrayList(FIEKDBJOCKI), + + pub const _desc_table = .{ + .PDAAJEDAIMG = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKIGFIPIDPJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFLHGDDJHHC = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGLFIDHLBPB = struct { + level: u32 = 0, + DCHFAONOOKK: u32 = 0, + LBHNMADMDBH: u32 = 0, + + pub const _desc_table = .{ + .level = fd(12, .{ .Varint = .Simple }), + .DCHFAONOOKK = fd(2, .{ .Varint = .Simple }), + .LBHNMADMDBH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PANJFGJGLOL = struct { + DDJEHGICHKC: ArrayList(MGLFIDHLBPB), + + pub const _desc_table = .{ + .DDJEHGICHKC = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFKOEBLKDBA = struct { + IDFOBIKKAJG: u32 = 0, + CEBCFEOMABN: u32 = 0, + FJAHEJCCDHI: u32 = 0, + KOIMAACPIJO: u32 = 0, + JNJJMGJPMAM: u32 = 0, + AKJAKAAFFFA: u32 = 0, + NIFNEJPFBKI: bool = false, + INPDFOHLLGO: u32 = 0, + BFAELPFLGKD: u32 = 0, + + pub const _desc_table = .{ + .IDFOBIKKAJG = fd(13, .{ .Varint = .Simple }), + .CEBCFEOMABN = fd(6, .{ .Varint = .Simple }), + .FJAHEJCCDHI = fd(1, .{ .Varint = .Simple }), + .KOIMAACPIJO = fd(4, .{ .Varint = .Simple }), + .JNJJMGJPMAM = fd(12, .{ .Varint = .Simple }), + .AKJAKAAFFFA = fd(2, .{ .Varint = .Simple }), + .NIFNEJPFBKI = fd(9, .{ .Varint = .Simple }), + .INPDFOHLLGO = fd(15, .{ .Varint = .Simple }), + .BFAELPFLGKD = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPBMAOFCJEM = struct { + EIHPANJOLAL: u32 = 0, + LACNOCDMDEK: ?NFKOEBLKDBA = null, + + pub const _desc_table = .{ + .EIHPANJOLAL = fd(5, .{ .Varint = .Simple }), + .LACNOCDMDEK = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOBNJOEHEKP = struct { + NOJPMGONLPN: u32 = 0, + NBHPDMDNDKL: u32 = 0, + FHKDKCOMPOH: u32 = 0, + + pub const _desc_table = .{ + .NOJPMGONLPN = fd(8, .{ .Varint = .Simple }), + .NBHPDMDNDKL = fd(13, .{ .Varint = .Simple }), + .FHKDKCOMPOH = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLGMNAAKMKD = struct { + buff_list: ArrayList(NOBNJOEHEKP), + + pub const _desc_table = .{ + .buff_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPEOBDLLBFG = struct { + CJHLOHBMLNI: u32 = 0, + uid: u32 = 0, + AKJAKAAFFFA: u32 = 0, + PKHNDLGCLPB: u32 = 0, + KOIMAACPIJO: u32 = 0, + + pub const _desc_table = .{ + .CJHLOHBMLNI = fd(5, .{ .Varint = .Simple }), + .uid = fd(8, .{ .Varint = .Simple }), + .AKJAKAAFFFA = fd(14, .{ .Varint = .Simple }), + .PKHNDLGCLPB = fd(6, .{ .Varint = .Simple }), + .KOIMAACPIJO = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJIBGMBEJIK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IMBCKJCKHMH = struct { + COPLNOGMHBA: ArrayList(JPEOBDLLBFG), + retcode: u32 = 0, + KNAGHJFGFMH: ?JPEOBDLLBFG = null, + + pub const _desc_table = .{ + .COPLNOGMHBA = fd(12, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(8, .{ .Varint = .Simple }), + .KNAGHJFGFMH = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIMKHMGGHOH = struct { + GMFJJGPPBMD: u32 = 0, + + pub const _desc_table = .{ + .GMFJJGPPBMD = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKNNMECKELC = struct { + EADGDKMCPCI: ?ItemList = null, + retcode: u32 = 0, + GMFJJGPPBMD: u32 = 0, + + pub const _desc_table = .{ + .EADGDKMCPCI = fd(2, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + .GMFJJGPPBMD = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDLOONNHLBP = struct { + MKICOAABLKA: ArrayList(u32), + CJHLOHBMLNI: u32 = 0, + + pub const _desc_table = .{ + .MKICOAABLKA = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .CJHLOHBMLNI = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFFHOKIINFI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFOOAINGPFF = struct { + cnt: u32 = 0, + MLOGCDGOBDH: u32 = 0, + + pub const _desc_table = .{ + .cnt = fd(6, .{ .Varint = .Simple }), + .MLOGCDGOBDH = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDMAGJDOGKG = struct { + MBEDCLKGPEA: bool = false, + ENCEOECDKFK: bool = false, + progress: u32 = 0, + ODFFHKDCFOG: i32 = 0, + retcode: u32 = 0, + IGPBJIMIILF: ArrayList(OFOOAINGPFF), + EMKNBMDJALN: ArrayList(JMLKGHLGIBI), + DEANJFEGCPA: i32 = 0, + + pub const _desc_table = .{ + .MBEDCLKGPEA = fd(10, .{ .Varint = .Simple }), + .ENCEOECDKFK = fd(14, .{ .Varint = .Simple }), + .progress = fd(1, .{ .Varint = .Simple }), + .ODFFHKDCFOG = fd(7, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .IGPBJIMIILF = fd(11, .{ .List = .{ .SubMessage = {} } }), + .EMKNBMDJALN = fd(15, .{ .List = .{ .SubMessage = {} } }), + .DEANJFEGCPA = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PANMGJPHKKM = struct { + PIJIFDHMCLJ: bool = false, + AALNGMJIDHD: u32 = 0, + + pub const _desc_table = .{ + .PIJIFDHMCLJ = fd(10, .{ .Varint = .Simple }), + .AALNGMJIDHD = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BAKKMIEFLDA = struct { + retcode: u32 = 0, + GEJIEPKHCKN: u32 = 0, + EAIFLKDLGKB: u32 = 0, + PLOOMKKHLNF: ?IMPCIBMECLB = null, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .GEJIEPKHCKN = fd(2, .{ .Varint = .Simple }), + .EAIFLKDLGKB = fd(12, .{ .Varint = .Simple }), + .PLOOMKKHLNF = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SocialEventServerCache = struct { + src_uid: u32 = 0, + add_coin: u32 = 0, + id: u32 = 0, + sub_coin: u32 = 0, + + pub const _desc_table = .{ + .src_uid = fd(7, .{ .Varint = .Simple }), + .add_coin = fd(4, .{ .Varint = .Simple }), + .id = fd(3, .{ .Varint = .Simple }), + .sub_coin = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POAAOINFOMN = struct { + KELPDEIAPLA: ArrayList(SocialEventServerCache), + + pub const _desc_table = .{ + .KELPDEIAPLA = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEBMEKIEEIO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPMBALAFADJ = struct { + retcode: u32 = 0, + KELPDEIAPLA: ArrayList(SocialEventServerCache), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .KELPDEIAPLA = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOJGKELBJDF = struct { + GCAIACDCGCK: ArrayList(u32), + + pub const _desc_table = .{ + .GCAIACDCGCK = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AECMODJFNHK = struct { + FGILIAJOENK: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .FGILIAJOENK = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNLONHLHMEE = struct { + KCHPOKNOMIA: u32 = 0, + + pub const _desc_table = .{ + .KCHPOKNOMIA = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AOGCFJPIJNC = struct { + KCHPOKNOMIA: u32 = 0, + retcode: u32 = 0, + JAELCKAMEAH: ArrayList(LDNACICHLEA), + + pub const _desc_table = .{ + .KCHPOKNOMIA = fd(2, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + .JAELCKAMEAH = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OBEKFHLNJKL = struct { + JNKKBOOKEHN: u64 = 0, + KCHPOKNOMIA: u32 = 0, + + pub const _desc_table = .{ + .JNKKBOOKEHN = fd(14, .{ .Varint = .Simple }), + .KCHPOKNOMIA = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFHFMINHOOA = struct { + JNKKBOOKEHN: u32 = 0, + retcode: u32 = 0, + EADGDKMCPCI: ?ItemList = null, + KCHPOKNOMIA: u32 = 0, + + pub const _desc_table = .{ + .JNKKBOOKEHN = fd(11, .{ .Varint = .Simple }), + .retcode = fd(9, .{ .Varint = .Simple }), + .EADGDKMCPCI = fd(8, .{ .SubMessage = {} }), + .KCHPOKNOMIA = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCMLJOBAMAC = struct { + KCHPOKNOMIA: u32 = 0, + JNKKBOOKEHN: u64 = 0, + + pub const _desc_table = .{ + .KCHPOKNOMIA = fd(3, .{ .Varint = .Simple }), + .JNKKBOOKEHN = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPGBMLLIHJM = struct { + JNKKBOOKEHN: u64 = 0, + KCHPOKNOMIA: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .JNKKBOOKEHN = fd(9, .{ .Varint = .Simple }), + .KCHPOKNOMIA = fd(12, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IIGOFHCLOHK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHNOMIFBFPF = struct { + PKHNDLGCLPB: u32 = 0, + NPILKMLMBEN: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .PKHNDLGCLPB = fd(12, .{ .Varint = .Simple }), + .NPILKMLMBEN = fd(3, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPGDGFPDJNP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBPALAEJALF = struct { + retcode: u32 = 0, + PLDNMECDKIN: ?JIONFPDOKEH = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .PLDNMECDKIN = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNNHOKCDEPC = struct { + EKGEJGKKDBD: ArrayList(u32), + + pub const _desc_table = .{ + .EKGEJGKKDBD = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GOKGJOOKEDJ = struct { + EADGDKMCPCI: ?ItemList = null, + EKGEJGKKDBD: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .EADGDKMCPCI = fd(2, .{ .SubMessage = {} }), + .EKGEJGKKDBD = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JEICCGJFNCE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMJGLPLCPFB = struct { + retcode: u32 = 0, + EADGDKMCPCI: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .EADGDKMCPCI = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMPHKIJAGFN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFCCLFFDIEE = struct { + LACNOCDMDEK: ?NFKOEBLKDBA = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LACNOCDMDEK = fd(5, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KNCPOMAPGOJ = struct { + JLJIKLDHIJE: u32 = 0, + EGKOJHEIOHH: u32 = 0, + + pub const _desc_table = .{ + .JLJIKLDHIJE = fd(10, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNLHICHEGFM = struct { + JLJIKLDHIJE: u32 = 0, + retcode: u32 = 0, + EGKOJHEIOHH: u32 = 0, + + pub const _desc_table = .{ + .JLJIKLDHIJE = fd(6, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKIPIBPOIEH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HAFLAHGBCOK = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFNALABHJCG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPGLKGALEGI = struct { + AOHJJJHMGHM: ?PEGAEGMBJBI = null, + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + retcode: u32 = 0, + + pub const _desc_table = .{ + .AOHJJJHMGHM = fd(13, .{ .SubMessage = {} }), + .DOLKBPLJGNO = fd(2, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AINFLGMKOFE = struct { + GMDFMEOPOJH: u32 = 0, + + pub const _desc_table = .{ + .GMDFMEOPOJH = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFIHKJOMPEK = struct { + ip: ManagedString = .Empty, + retcode: u32 = 0, + ILGJLGKPDON: u64 = 0, + port: u32 = 0, + LGIPENPDGMC: ManagedString = .Empty, + + pub const _desc_table = .{ + .ip = fd(4, .String), + .retcode = fd(7, .{ .Varint = .Simple }), + .ILGJLGKPDON = fd(14, .{ .Varint = .Simple }), + .port = fd(15, .{ .Varint = .Simple }), + .LGIPENPDGMC = fd(9, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GMCDNOHGGMM = struct { + ILGJLGKPDON: u64 = 0, + + pub const _desc_table = .{ + .ILGJLGKPDON = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDMIGFHNNOD = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOEEJHGHIOJ = struct { + DOLKBPLJGNO: ArrayList(NJMGIJBHCPE), + AOHJJJHMGHM: ?PEGAEGMBJBI = null, + + pub const _desc_table = .{ + .DOLKBPLJGNO = fd(3, .{ .List = .{ .SubMessage = {} } }), + .AOHJJJHMGHM = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LALHNHDEHGK = struct { + AOHJJJHMGHM: ?PEGAEGMBJBI = null, + + pub const _desc_table = .{ + .AOHJJJHMGHM = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPJMDAOOING = struct { + DJPAJNOCHHG: u32 = 0, + FJAFGJLFJGD: u32 = 0, + NLEFHGHGKPE: PNDLEEJDNJG = @enumFromInt(0), + FANMEJFOCIL: ?HLEMBLOIKAM = null, + + pub const _desc_table = .{ + .DJPAJNOCHHG = fd(7, .{ .Varint = .Simple }), + .FJAFGJLFJGD = fd(13, .{ .Varint = .Simple }), + .NLEFHGHGKPE = fd(10, .{ .Varint = .Simple }), + .FANMEJFOCIL = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMDJKDIKPCA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNNNIPPEDCH = struct { + id: u32 = 0, + HGKCGCNNILM: u32 = 0, + + pub const _desc_table = .{ + .id = fd(5, .{ .Varint = .Simple }), + .HGKCGCNNILM = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KBOKONJBFIH = struct { + retcode: u32 = 0, + OCOKAMDMEOI: ArrayList(PDHJFMAGJLI), + CINIKLIAPDF: ArrayList(DNNNIPPEDCH), + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .OCOKAMDMEOI = fd(13, .{ .List = .{ .SubMessage = {} } }), + .CINIKLIAPDF = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPOJGHFFLHH = struct { + CINIKLIAPDF: ArrayList(DNNNIPPEDCH), + + pub const _desc_table = .{ + .CINIKLIAPDF = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBDHPAOEPFF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KIOCIOPKFFG = struct { + KCLEGONEJLE: u32 = 0, + PLNJALLJIGE: u32 = 0, + MDKLBEIAGOH: u32 = 0, + ABEDIGLKNCF: u32 = 0, + + pub const _desc_table = .{ + .KCLEGONEJLE = fd(7, .{ .Varint = .Simple }), + .PLNJALLJIGE = fd(10, .{ .Varint = .Simple }), + .MDKLBEIAGOH = fd(2, .{ .Varint = .Simple }), + .ABEDIGLKNCF = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDHJFMAGJLI = struct { + ABEDIGLKNCF: u32 = 0, + IMFDLFIHJHC: u32 = 0, + NFNNOMAMNAA: u32 = 0, + PNEAMGJHJBH: u32 = 0, + + pub const _desc_table = .{ + .ABEDIGLKNCF = fd(15, .{ .Varint = .Simple }), + .IMFDLFIHJHC = fd(8, .{ .Varint = .Simple }), + .NFNNOMAMNAA = fd(5, .{ .Varint = .Simple }), + .PNEAMGJHJBH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIGNPNAAMKN = struct { + CHHGCMLNFCM: ?KIOCIOPKFFG = null, + OCOKAMDMEOI: ArrayList(PDHJFMAGJLI), + retcode: u32 = 0, + + pub const _desc_table = .{ + .CHHGCMLNFCM = fd(4, .{ .SubMessage = {} }), + .OCOKAMDMEOI = fd(5, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIKJJIOCEOP = struct { + MPCCOHPCBFM: ArrayList(KIOCIOPKFFG), + OCOKAMDMEOI: ArrayList(PDHJFMAGJLI), + CINIKLIAPDF: ArrayList(DNNNIPPEDCH), + + pub const _desc_table = .{ + .MPCCOHPCBFM = fd(4, .{ .List = .{ .SubMessage = {} } }), + .OCOKAMDMEOI = fd(1, .{ .List = .{ .SubMessage = {} } }), + .CINIKLIAPDF = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGJDIKHDJOM = struct { + CAPKIANAJIM: u32 = 0, + pos: BLHDECCDHDM = @enumFromInt(0), + + pub const _desc_table = .{ + .CAPKIANAJIM = fd(14, .{ .Varint = .Simple }), + .pos = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNMMELAIBJK = struct { + level: u32 = 0, + DGPECHFOPHK: u32 = 0, + GLGFCBDLOOI: ArrayList(GGJDIKHDJOM), + OIIBFPIBLBK: u32 = 0, + HMBIHJFHHHI: u32 = 0, + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .level = fd(4, .{ .Varint = .Simple }), + .DGPECHFOPHK = fd(13, .{ .Varint = .Simple }), + .GLGFCBDLOOI = fd(8, .{ .List = .{ .SubMessage = {} } }), + .OIIBFPIBLBK = fd(9, .{ .Varint = .Simple }), + .HMBIHJFHHHI = fd(14, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BODIPEDOOAN = struct { + DDNFCADFMOC: u32 = 0, + CHGPIDCCKEB: bool = false, + + pub const _desc_table = .{ + .DDNFCADFMOC = fd(8, .{ .Varint = .Simple }), + .CHGPIDCCKEB = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPNPOAAHDAC = struct { + IBEHAGFOEAO: u32 = 0, + BEGGIAEHOEG: u32 = 0, + AFLNDGDEHPJ: u32 = 0, + IBCDNPNAKAG: u32 = 0, + KGGBGBEKGNA: u32 = 0, + MDKIFKKPOCE: ArrayList(BODIPEDOOAN), + + pub const _desc_table = .{ + .IBEHAGFOEAO = fd(4, .{ .Varint = .Simple }), + .BEGGIAEHOEG = fd(12, .{ .Varint = .Simple }), + .AFLNDGDEHPJ = fd(8, .{ .Varint = .Simple }), + .IBCDNPNAKAG = fd(3, .{ .Varint = .Simple }), + .KGGBGBEKGNA = fd(13, .{ .Varint = .Simple }), + .MDKIFKKPOCE = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPOHDHHDOAE = struct { + CAPKIANAJIM: u32 = 0, + LALCDJKCHLE: u32 = 0, + + pub const _desc_table = .{ + .CAPKIANAJIM = fd(12, .{ .Varint = .Simple }), + .LALCDJKCHLE = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIBFGBHDPAM = struct { + event_id: u32 = 0, + FAGJDONPNNE: u32 = 0, + EOCPNIDFFDD: u32 = 0, + CGHBPPHAMCE: u32 = 0, + state: OHDDKHGHJAB = @enumFromInt(0), + NBMOOEFBEFD: ArrayList(u32), + FMCKENFKHFM: u32 = 0, + + pub const _desc_table = .{ + .event_id = fd(6, .{ .Varint = .Simple }), + .FAGJDONPNNE = fd(10, .{ .Varint = .Simple }), + .EOCPNIDFFDD = fd(7, .{ .Varint = .Simple }), + .CGHBPPHAMCE = fd(14, .{ .Varint = .Simple }), + .state = fd(1, .{ .Varint = .Simple }), + .NBMOOEFBEFD = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .FMCKENFKHFM = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPMIGBGLPNJ = struct { + ELKMMFNBOMO: u32 = 0, + NCOHHKFIFAF: ArrayList(u32), + KHOFMPHEFNC: ArrayList(CIBFGBHDPAM), + + pub const _desc_table = .{ + .ELKMMFNBOMO = fd(6, .{ .Varint = .Simple }), + .NCOHHKFIFAF = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .KHOFMPHEFNC = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CICAPHAOHGJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCMCCFEFELJ = struct { + MELNILMPOBA: ArrayList(MNMMELAIBJK), + MDHKFPDCFGP: ?KPNPOAAHDAC = null, + retcode: u32 = 0, + CCKBBOEOKGO: u32 = 0, + exp: u32 = 0, + ADOBEODJBLJ: ?IPMIGBGLPNJ = null, + level: u32 = 0, + EBNNBEEGJFN: u32 = 0, + NBBKPIJEJPP: u32 = 0, + PFGENNDADFA: u32 = 0, + ODNOFEPBJAG: ArrayList(u32), + GLGFCBDLOOI: ArrayList(OPOHDHHDOAE), + BHIHOPLDPGF: ArrayList(u32), + JOANGDLCHKM: u32 = 0, + + pub const _desc_table = .{ + .MELNILMPOBA = fd(4, .{ .List = .{ .SubMessage = {} } }), + .MDHKFPDCFGP = fd(13, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + .CCKBBOEOKGO = fd(6, .{ .Varint = .Simple }), + .exp = fd(3, .{ .Varint = .Simple }), + .ADOBEODJBLJ = fd(15, .{ .SubMessage = {} }), + .level = fd(11, .{ .Varint = .Simple }), + .EBNNBEEGJFN = fd(7, .{ .Varint = .Simple }), + .NBBKPIJEJPP = fd(9, .{ .Varint = .Simple }), + .PFGENNDADFA = fd(1, .{ .Varint = .Simple }), + .ODNOFEPBJAG = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .GLGFCBDLOOI = fd(8, .{ .List = .{ .SubMessage = {} } }), + .BHIHOPLDPGF = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .JOANGDLCHKM = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLCACDAOEGD = struct { + CAPKIANAJIM: u32 = 0, + + pub const _desc_table = .{ + .CAPKIANAJIM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HILBGOMLGHK = struct { + retcode: u32 = 0, + CAPKIANAJIM: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .CAPKIANAJIM = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPDEIJNFMCC = struct { + LALCDJKCHLE: u32 = 0, + pos: BLHDECCDHDM = @enumFromInt(0), + CAPKIANAJIM: u32 = 0, + + pub const _desc_table = .{ + .LALCDJKCHLE = fd(10, .{ .Varint = .Simple }), + .pos = fd(13, .{ .Varint = .Simple }), + .CAPKIANAJIM = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEJICABNFBO = struct { + LALCDJKCHLE: u32 = 0, + CAPKIANAJIM: u32 = 0, + pos: BLHDECCDHDM = @enumFromInt(0), + retcode: u32 = 0, + + pub const _desc_table = .{ + .LALCDJKCHLE = fd(11, .{ .Varint = .Simple }), + .CAPKIANAJIM = fd(14, .{ .Varint = .Simple }), + .pos = fd(2, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HHKLGONOALD = struct { + CAPKIANAJIM: u32 = 0, + + pub const _desc_table = .{ + .CAPKIANAJIM = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLFIAAALMGM = struct { + retcode: u32 = 0, + CAPKIANAJIM: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .CAPKIANAJIM = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCDGEHKFHDM = struct { + IBPAGGPKNHJ: LMIKHOBPLCA = @enumFromInt(0), + CAPKIANAJIM: u32 = 0, + + pub const _desc_table = .{ + .IBPAGGPKNHJ = fd(11, .{ .Varint = .Simple }), + .CAPKIANAJIM = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPBKBJNMKCG = struct { + HEGNAINOGNL: u32 = 0, + + pub const _desc_table = .{ + .HEGNAINOGNL = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELHFGDFGOJN = struct { + KMOMFEMIFID: u32 = 0, + + pub const _desc_table = .{ + .KMOMFEMIFID = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCOKBAKFBPD = struct { + NMJPHLOEENH: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NMJPHLOEENH = fd(15, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIPGIGJPOJF = struct { + level: u32 = 0, + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .level = fd(4, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMNJPKFHIPF = struct { + level: u32 = 0, + ONBDKKFHLAO: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .level = fd(2, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(4, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDOCNGNELHC = struct { + ONBDKKFHLAO: u32 = 0, + level: u32 = 0, + JPKIBNIHGOD: JFLBDNGFGMD = @enumFromInt(0), + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(14, .{ .Varint = .Simple }), + .level = fd(12, .{ .Varint = .Simple }), + .JPKIBNIHGOD = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PELPFHEPEGE = struct { + JPKIBNIHGOD: JFLBDNGFGMD = @enumFromInt(0), + ONBDKKFHLAO: u32 = 0, + retcode: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .JPKIBNIHGOD = fd(13, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(14, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + .level = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKCJHLJBICP = struct { + JOANGDLCHKM: u32 = 0, + NBBKPIJEJPP: u32 = 0, + MELNILMPOBA: ArrayList(MNMMELAIBJK), + BHIHOPLDPGF: ArrayList(u32), + CCKBBOEOKGO: u32 = 0, + PFGENNDADFA: u32 = 0, + ODNOFEPBJAG: ArrayList(u32), + GLGFCBDLOOI: ArrayList(OPOHDHHDOAE), + EBNNBEEGJFN: u32 = 0, + level: u32 = 0, + MDHKFPDCFGP: ?KPNPOAAHDAC = null, + ADOBEODJBLJ: ?IPMIGBGLPNJ = null, + exp: u32 = 0, + + pub const _desc_table = .{ + .JOANGDLCHKM = fd(14, .{ .Varint = .Simple }), + .NBBKPIJEJPP = fd(10, .{ .Varint = .Simple }), + .MELNILMPOBA = fd(13, .{ .List = .{ .SubMessage = {} } }), + .BHIHOPLDPGF = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .CCKBBOEOKGO = fd(2, .{ .Varint = .Simple }), + .PFGENNDADFA = fd(15, .{ .Varint = .Simple }), + .ODNOFEPBJAG = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .GLGFCBDLOOI = fd(1, .{ .List = .{ .SubMessage = {} } }), + .EBNNBEEGJFN = fd(6, .{ .Varint = .Simple }), + .level = fd(8, .{ .Varint = .Simple }), + .MDHKFPDCFGP = fd(11, .{ .SubMessage = {} }), + .ADOBEODJBLJ = fd(9, .{ .SubMessage = {} }), + .exp = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CACKJGIMCCF = struct { + ILGGJOFHOCN: ?CIBFGBHDPAM = null, + + pub const _desc_table = .{ + .ILGGJOFHOCN = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJBONKOLDNA = struct { + DDMHOKOAAIH: i32 = 0, + + pub const _desc_table = .{ + .DDMHOKOAAIH = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIMDGLJBFMH = struct { + retcode: u32 = 0, + ILGGJOFHOCN: ?IPMIGBGLPNJ = null, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .ILGGJOFHOCN = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEMHOOLGIEJ = struct { + CGHBPPHAMCE: u32 = 0, + event_id: u32 = 0, + + pub const _desc_table = .{ + .CGHBPPHAMCE = fd(12, .{ .Varint = .Simple }), + .event_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBOPPLLCECJ = struct { + CGHBPPHAMCE: u32 = 0, + retcode: u32 = 0, + event_id: u32 = 0, + + pub const _desc_table = .{ + .CGHBPPHAMCE = fd(13, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .event_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFKJJDCAIDJ = struct { + EBNNBEEGJFN: u32 = 0, + + pub const _desc_table = .{ + .EBNNBEEGJFN = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KNMODBGGOLG = struct { + LPDIKKFDNPG: u32 = 0, + CAPKIANAJIM: u32 = 0, + EBNNBEEGJFN: u32 = 0, + LDCPKCKNMMJ: u32 = 0, + + pub const _desc_table = .{ + .LPDIKKFDNPG = fd(6, .{ .Varint = .Simple }), + .CAPKIANAJIM = fd(10, .{ .Varint = .Simple }), + .EBNNBEEGJFN = fd(14, .{ .Varint = .Simple }), + .LDCPKCKNMMJ = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KBNJKPDOFHE = struct { + BEGGIAEHOEG: u32 = 0, + + pub const _desc_table = .{ + .BEGGIAEHOEG = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNOEEAAAEBD = struct { + DDNFCADFMOC: ArrayList(u32), + BEGGIAEHOEG: u32 = 0, + IOGKJDKKIEO: bool = false, + + pub const _desc_table = .{ + .DDNFCADFMOC = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .BEGGIAEHOEG = fd(10, .{ .Varint = .Simple }), + .IOGKJDKKIEO = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBPMMHFIHEE = struct { + BEGGIAEHOEG: u32 = 0, + GBIEPAPENKJ: u32 = 0, + DJOAJNAHOKB: u32 = 0, + + pub const _desc_table = .{ + .BEGGIAEHOEG = fd(15, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(2, .{ .Varint = .Simple }), + .DJOAJNAHOKB = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEFNJKFFJKJ = struct { + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHONKDHALKH = struct { + ADKJIIANOOM: ?ItemList = null, + GBIEPAPENKJ: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(7, .{ .SubMessage = {} }), + .GBIEPAPENKJ = fd(11, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNOGMBJEGJD = struct { + ADFPFJNNOGA: u32 = 0, + DDIEHKFOKOC: u32 = 0, + HMGJGHACIGM: ArrayList(u32), + BBOAEJKGEBO: u32 = 0, + HKNLFIKBOBD: u32 = 0, + AJIMLCLOEKJ: MHAKLHHANJL = @enumFromInt(0), + + pub const _desc_table = .{ + .ADFPFJNNOGA = fd(8, .{ .Varint = .Simple }), + .DDIEHKFOKOC = fd(10, .{ .Varint = .Simple }), + .HMGJGHACIGM = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .BBOAEJKGEBO = fd(4, .{ .Varint = .Simple }), + .HKNLFIKBOBD = fd(14, .{ .Varint = .Simple }), + .AJIMLCLOEKJ = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNLBGPHLHBL = struct { + PHAKFAJPOJI: ArrayList(u32), + + pub const _desc_table = .{ + .PHAKFAJPOJI = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMEFAKAEJPF = struct { + retcode: u32 = 0, + LFABPFOIOOJ: ArrayList(HNOGMBJEGJD), + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .LFABPFOIOOJ = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NABFKJKMMLB = struct { + LDOLLOOEIKA: u32 = 0, + BBOAEJKGEBO: u32 = 0, + + pub const _desc_table = .{ + .LDOLLOOEIKA = fd(8, .{ .Varint = .Simple }), + .BBOAEJKGEBO = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IAEKKICHMFM = struct { + retcode: u32 = 0, + NICMGEMINDM: ?HNOGMBJEGJD = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .NICMGEMINDM = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PILCLLJDILN = struct { + BBOAEJKGEBO: u32 = 0, + LDOLLOOEIKA: u32 = 0, + KMHLLGLJNMN: ArrayList(u32), + + pub const _desc_table = .{ + .BBOAEJKGEBO = fd(4, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(14, .{ .Varint = .Simple }), + .KMHLLGLJNMN = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKGJGPKNBIN = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + NICMGEMINDM: ?HNOGMBJEGJD = null, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(11, .{ .SubMessage = {} }), + .retcode = fd(8, .{ .Varint = .Simple }), + .NICMGEMINDM = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCMDAHBMDCH = struct { + NICMGEMINDM: ?HNOGMBJEGJD = null, + + pub const _desc_table = .{ + .NICMGEMINDM = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNAKEKJOGJM = struct { + MELNHGLIDKJ: u32 = 0, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIOLPPKLHOM = struct { + MELNHGLIDKJ: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(6, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHIMKLFGLNF = struct { + MELNHGLIDKJ: u32 = 0, + IINIHAKIPAE: u64 = 0, + + pub const _desc_table = .{ + .MELNHGLIDKJ = fd(8, .{ .Varint = .Simple }), + .IINIHAKIPAE = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGKOELIKHND = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJLDGFMBIHO = struct { + NLNFFOHPJEP: u32 = 0, + HJEFNIKONIH: ArrayList(u32), + FDDGOPBNKFA: u32 = 0, + BBJCNANPIKP: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .NLNFFOHPJEP = fd(14, .{ .Varint = .Simple }), + .HJEFNIKONIH = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .FDDGOPBNKFA = fd(15, .{ .Varint = .Simple }), + .BBJCNANPIKP = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMEACDBCBCA = struct { + HAFBAKCMEKJ: u32 = 0, + + pub const _desc_table = .{ + .HAFBAKCMEKJ = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ACMNMNHDIIA = struct { + BDDJODIMMGO: u32 = 0, + retcode: u32 = 0, + FDDGOPBNKFA: u32 = 0, + + pub const _desc_table = .{ + .BDDJODIMMGO = fd(6, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .FDDGOPBNKFA = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDEGIJJGCMI = struct { + HAFBAKCMEKJ: u32 = 0, + + pub const _desc_table = .{ + .HAFBAKCMEKJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDAEDAMNKKI = struct { + OGENCAEFOOA: u32 = 0, + + pub const _desc_table = .{ + .OGENCAEFOOA = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIPDJMEKKBH = struct { + retcode: u32 = 0, + NLNFFOHPJEP: u32 = 0, + NNKFBKLCDDF: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .NLNFFOHPJEP = fd(9, .{ .Varint = .Simple }), + .NNKFBKLCDDF = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJONCGONAMC = struct { + OGENCAEFOOA: u32 = 0, + + pub const _desc_table = .{ + .OGENCAEFOOA = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerLoginCsReq = struct { + ILEHKCJPGGE: ManagedString = .Empty, + PLINCKJBBMN: ManagedString = .Empty, + LGLEFCNIJKL: ManagedString = .Empty, + login_random: u64 = 0, + KEAPPFOFEJI: ManagedString = .Empty, + language: LanguageType = @enumFromInt(0), + DHICFKJEPBI: u32 = 0, + MDDDOKFINDH: ManagedString = .Empty, + JJNINCMBIDN: ManagedString = .Empty, + OPIACEKOANJ: ManagedString = .Empty, + NJLPCOEBMFJ: ManagedString = .Empty, + LGOMKMJMEDM: ManagedString = .Empty, + BCIJKADEMIE: ManagedString = .Empty, + GIMCNHMAPBP: ManagedString = .Empty, + platform: PlatformType = @enumFromInt(0), + CIDHAHDCHDL: u32 = 0, + AJDGHADCPGM: u32 = 0, + MCKKBKPOMLI: ManagedString = .Empty, + GANJMFCLNFL: ?GBAMNAPGHFF = null, + DINGJPLIJKG: ManagedString = .Empty, + OKPDCDEDOIL: u32 = 0, + BOLHLHDEGGG: ManagedString = .Empty, + HKIGMBKIDLA: ManagedString = .Empty, + BHHOMHKAMLO: bool = false, + + pub const _desc_table = .{ + .ILEHKCJPGGE = fd(8, .String), + .PLINCKJBBMN = fd(10, .String), + .LGLEFCNIJKL = fd(13, .String), + .login_random = fd(9, .{ .Varint = .Simple }), + .KEAPPFOFEJI = fd(4, .String), + .language = fd(7, .{ .Varint = .Simple }), + .DHICFKJEPBI = fd(1687, .{ .Varint = .Simple }), + .MDDDOKFINDH = fd(12, .String), + .JJNINCMBIDN = fd(5, .String), + .OPIACEKOANJ = fd(188, .String), + .NJLPCOEBMFJ = fd(2, .String), + .LGOMKMJMEDM = fd(155, .String), + .BCIJKADEMIE = fd(940, .String), + .GIMCNHMAPBP = fd(11, .String), + .platform = fd(3, .{ .Varint = .Simple }), + .CIDHAHDCHDL = fd(15, .{ .Varint = .Simple }), + .AJDGHADCPGM = fd(1, .{ .Varint = .Simple }), + .MCKKBKPOMLI = fd(138, .String), + .GANJMFCLNFL = fd(885, .{ .SubMessage = {} }), + .DINGJPLIJKG = fd(6, .String), + .OKPDCDEDOIL = fd(1630, .{ .Varint = .Simple }), + .BOLHLHDEGGG = fd(2038, .String), + .HKIGMBKIDLA = fd(14, .String), + .BHHOMHKAMLO = fd(801, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerLoginScRsp = struct { + stamina: u32 = 0, + retcode: u32 = 0, + login_random: u64 = 0, + basic_info: ?PlayerBasicInfo = null, + server_timestamp_ms: u64 = 0, + IIHIIKMOJFF: i32 = 0, + BMJBBGCMBPH: ManagedString = .Empty, + KOMBCEDDLDJ: ManagedString = .Empty, + HOCBCAGBIIA: bool = false, + EPKIGLGBEBN: bool = false, + + pub const _desc_table = .{ + .stamina = fd(13, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + .login_random = fd(2, .{ .Varint = .Simple }), + .basic_info = fd(11, .{ .SubMessage = {} }), + .server_timestamp_ms = fd(14, .{ .Varint = .Simple }), + .IIHIIKMOJFF = fd(3, .{ .Varint = .Simple }), + .BMJBBGCMBPH = fd(15, .String), + .KOMBCEDDLDJ = fd(5, .String), + .HOCBCAGBIIA = fd(9, .{ .Varint = .Simple }), + .EPKIGLGBEBN = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerLogoutCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerGetTokenCsReq = struct { + DHICFKJEPBI: u32 = 0, + DHDMABNFKBM: ManagedString = .Empty, + OKHLBOKCMMK: u32 = 0, + GFAONIKMGAD: ManagedString = .Empty, + uid: u32 = 0, + NCMOBOONKIJ: u32 = 0, + platform: u32 = 0, + PKKALPFLMMA: ManagedString = .Empty, + + pub const _desc_table = .{ + .DHICFKJEPBI = fd(10, .{ .Varint = .Simple }), + .DHDMABNFKBM = fd(1, .String), + .OKHLBOKCMMK = fd(7, .{ .Varint = .Simple }), + .GFAONIKMGAD = fd(11, .String), + .uid = fd(2, .{ .Varint = .Simple }), + .NCMOBOONKIJ = fd(8, .{ .Varint = .Simple }), + .platform = fd(15, .{ .Varint = .Simple }), + .PKKALPFLMMA = fd(12, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerGetTokenScRsp = struct { + retcode: u32 = 0, + msg: ManagedString = .Empty, + black_info: ?BlackInfo = null, + uid: u32 = 0, + secret_key_seed: u64 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .msg = fd(2, .String), + .black_info = fd(5, .{ .SubMessage = {} }), + .uid = fd(1, .{ .Varint = .Simple }), + .secret_key_seed = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCGGMOOPMII = struct { + msg: ManagedString = .Empty, + + pub const _desc_table = .{ + .msg = fd(4, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerKickOutScNotify = struct { + black_info: ?BlackInfo = null, + kick_type: KickType = @enumFromInt(0), + + pub const _desc_table = .{ + .black_info = fd(10, .{ .SubMessage = {} }), + .kick_type = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GmTalkCsReq = struct { + msg: ManagedString = .Empty, + + pub const _desc_table = .{ + .msg = fd(9, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GmTalkScRsp = struct { + retcode: u32 = 0, + retmsg: ManagedString = .Empty, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .retmsg = fd(4, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetBasicInfoCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerSettingInfo = struct { + NLDNPGELJMG: bool = false, + DAFHJJEDMOF: bool = false, + LFEBNOLONGM: bool = false, + BPELFJGIJID: bool = false, + FOKLJKEEIPN: bool = false, + KDAKDMCGFND: bool = false, + LFGHGADKHPD: bool = false, + DKLJGCEHPJL: bool = false, + EPMCKMCDIGB: JLMBAEKILPG = @enumFromInt(0), + KEACGBKOFKF: bool = false, + + pub const _desc_table = .{ + .NLDNPGELJMG = fd(7, .{ .Varint = .Simple }), + .DAFHJJEDMOF = fd(14, .{ .Varint = .Simple }), + .LFEBNOLONGM = fd(4, .{ .Varint = .Simple }), + .BPELFJGIJID = fd(11, .{ .Varint = .Simple }), + .FOKLJKEEIPN = fd(1, .{ .Varint = .Simple }), + .KDAKDMCGFND = fd(15, .{ .Varint = .Simple }), + .LFGHGADKHPD = fd(10, .{ .Varint = .Simple }), + .DKLJGCEHPJL = fd(8, .{ .Varint = .Simple }), + .EPMCKMCDIGB = fd(6, .{ .Varint = .Simple }), + .KEACGBKOFKF = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetBasicInfoScRsp = struct { + next_recover_time: i64 = 0, + week_cocoon_finished_count: u32 = 0, + last_set_nickname_time: i64 = 0, + gender: u32 = 0, + player_setting_info: ?PlayerSettingInfo = null, + exchange_times: u32 = 0, + gameplay_birthday: u32 = 0, + IsGenderSet: bool = false, + cur_day: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .next_recover_time = fd(6, .{ .Varint = .Simple }), + .week_cocoon_finished_count = fd(10, .{ .Varint = .Simple }), + .last_set_nickname_time = fd(15, .{ .Varint = .Simple }), + .gender = fd(14, .{ .Varint = .Simple }), + .player_setting_info = fd(4, .{ .SubMessage = {} }), + .exchange_times = fd(11, .{ .Varint = .Simple }), + .gameplay_birthday = fd(8, .{ .Varint = .Simple }), + .IsGenderSet = fd(9, .{ .Varint = .Simple }), + .cur_day = fd(2, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ExchangeStaminaCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ExchangeStaminaScRsp = struct { + exchange_times: u32 = 0, + stamina_add: u32 = 0, + item_cost_list: ArrayList(ItemCost), + retcode: u32 = 0, + last_recover_time: i64 = 0, + + pub const _desc_table = .{ + .exchange_times = fd(7, .{ .Varint = .Simple }), + .stamina_add = fd(5, .{ .Varint = .Simple }), + .item_cost_list = fd(13, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(11, .{ .Varint = .Simple }), + .last_recover_time = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetAuthkeyCsReq = struct { + auth_appid: ManagedString = .Empty, + ADIOHJGIBLP: u32 = 0, + LIKAEKCNMHN: u32 = 0, + + pub const _desc_table = .{ + .auth_appid = fd(12, .String), + .ADIOHJGIBLP = fd(14, .{ .Varint = .Simple }), + .LIKAEKCNMHN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetAuthkeyScRsp = struct { + retcode: u32 = 0, + auth_appid: ManagedString = .Empty, + authkey: ManagedString = .Empty, + LIKAEKCNMHN: u32 = 0, + ADIOHJGIBLP: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .auth_appid = fd(3, .String), + .authkey = fd(15, .String), + .LIKAEKCNMHN = fd(4, .{ .Varint = .Simple }), + .ADIOHJGIBLP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RegionStopScNotify = struct { + OFGPAONJADM: i64 = 0, + AGMKEMOJHHJ: i64 = 0, + + pub const _desc_table = .{ + .OFGPAONJADM = fd(13, .{ .Varint = .Simple }), + .AGMKEMOJHHJ = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AntiAddictScNotify = struct { + msg_type: u32 = 0, + level: ManagedString = .Empty, + msg: ManagedString = .Empty, + + pub const _desc_table = .{ + .msg_type = fd(8, .{ .Varint = .Simple }), + .level = fd(12, .String), + .msg = fd(6, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetNicknameCsReq = struct { + nickname: ManagedString = .Empty, + is_modify: bool = false, + + pub const _desc_table = .{ + .nickname = fd(15, .String), + .is_modify = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetNicknameScRsp = struct { + is_modify: bool = false, + LBLMBAEBPBN: i64 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .is_modify = fd(6, .{ .Varint = .Simple }), + .LBLMBAEBPBN = fd(11, .{ .Varint = .Simple }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetLevelRewardTakenListCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetLevelRewardTakenListScRsp = struct { + retcode: u32 = 0, + taken_level_list: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .taken_level_list = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOHIHPCCCOH = struct { + LDOLLOOEIKA: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .LDOLLOOEIKA = fd(10, .{ .Varint = .Simple }), + .level = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PAGCNLHHNPC = struct { + level: u32 = 0, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .level = fd(7, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetLanguageCsReq = struct { + language: LanguageType = @enumFromInt(0), + + pub const _desc_table = .{ + .language = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetLanguageScRsp = struct { + language: LanguageType = @enumFromInt(0), + retcode: u32 = 0, + + pub const _desc_table = .{ + .language = fd(5, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFIAIOHDCDM = struct { + begin_time: i64 = 0, + MFNLOJOMOAI: u32 = 0, + GGKNOFCPGKP: ManagedString = .Empty, + BMABEHFEHLF: ManagedString = .Empty, + KFOMLPMMHCA: bool = false, + DGFLHAEFBEP: u32 = 0, + ALJACEDDGHA: ManagedString = .Empty, + IEJNHFPDFGE: u32 = 0, + end_time: i64 = 0, + + pub const _desc_table = .{ + .begin_time = fd(13, .{ .Varint = .Simple }), + .MFNLOJOMOAI = fd(9, .{ .Varint = .Simple }), + .GGKNOFCPGKP = fd(4, .String), + .BMABEHFEHLF = fd(10, .String), + .KFOMLPMMHCA = fd(14, .{ .Varint = .Simple }), + .DGFLHAEFBEP = fd(11, .{ .Varint = .Simple }), + .ALJACEDDGHA = fd(3, .String), + .IEJNHFPDFGE = fd(8, .{ .Varint = .Simple }), + .end_time = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBAIEJIDMLG = struct { + DGPODMKKCIJ: ArrayList(DFIAIOHDCDM), + + pub const _desc_table = .{ + .DGPODMKKCIJ = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Gateserver = struct { + JIHFOLPBFFL: ManagedString = .Empty, + AIFBLJAACHO: ManagedString = .Empty, + LGPAAPCPBMD: bool = false, + NAHBLPGMKJC: ManagedString = .Empty, + retcode: u32 = 0, + AOEKIKFKMGA: bool = false, + CLJNMIKINLN: ManagedString = .Empty, + GJMFLPHIDFD: ArrayList(ManagedString), + DMBNKOFDBNL: bool = false, + lua_url: ManagedString = .Empty, + HJPAPNPPNNH: ManagedString = .Empty, + CDHOIAAONHD: bool = false, + DHKIEGBPJML: ManagedString = .Empty, + region_name: ManagedString = .Empty, + OMDAJOMPIMG: ManagedString = .Empty, + KFIGINFCAKM: ManagedString = .Empty, + FPHMEDIMIOB: ManagedString = .Empty, + GOELMBPGOFC: bool = false, + MCANJEHAEKO: bool = false, + ifix_version: ManagedString = .Empty, + KJOPNFNPOML: ManagedString = .Empty, + CIKOEPDNJBA: ManagedString = .Empty, + DIECBLIJNPO: ManagedString = .Empty, + FEJLKGFLMNF: ManagedString = .Empty, + ex_resource_url: ManagedString = .Empty, + CIGLGHGDBHB: ManagedString = .Empty, + GAHDEBODOPK: ManagedString = .Empty, + ip: ManagedString = .Empty, + AGMKEMOJHHJ: i64 = 0, + KDGOBNKMNKC: u32 = 0, + msg: ManagedString = .Empty, + GEBNKMIPOMM: bool = false, + EBNBNCHNOFH: ManagedString = .Empty, + GLCOMFKHDGH: ManagedString = .Empty, + GECDDMDAGCL: ManagedString = .Empty, + FABJDGBFAFF: ManagedString = .Empty, + use_tcp: bool = false, + JPGHOAAFODJ: ManagedString = .Empty, + BKMDGECDJLJ: ManagedString = .Empty, + CCFBLAONHAF: u32 = 0, + FKFKCDJNHFL: bool = false, + MFENPHLEGHJ: bool = false, + MFFMCCGBHBJ: bool = false, + FOPDCGLBOOI: ManagedString = .Empty, + GNFPFKJHIDJ: bool = false, + LHKJHDCIDND: ManagedString = .Empty, + ALNIFJLCIJJ: ManagedString = .Empty, + AGEBFKODEAE: ManagedString = .Empty, + client_secret_key: ManagedString = .Empty, + NNPPEAAIHAK: bool = false, + PAIINFFIDLH: bool = false, + PGMFEHFKLBG: bool = false, + NCDIJNHGELK: u32 = 0, + lua_version: ManagedString = .Empty, + NMKHBELIAOK: ManagedString = .Empty, + ALEILJPDNFF: ManagedString = .Empty, + OFGPAONJADM: i64 = 0, + port: u32 = 0, + asset_bundle_url: ManagedString = .Empty, + + pub const _desc_table = .{ + .JIHFOLPBFFL = fd(1706, .String), + .AIFBLJAACHO = fd(383, .String), + .LGPAAPCPBMD = fd(737, .{ .Varint = .Simple }), + .NAHBLPGMKJC = fd(1829, .String), + .retcode = fd(3, .{ .Varint = .Simple }), + .AOEKIKFKMGA = fd(1851, .{ .Varint = .Simple }), + .CLJNMIKINLN = fd(1197, .String), + .GJMFLPHIDFD = fd(1394, .{ .List = .String }), + .DMBNKOFDBNL = fd(210, .{ .Varint = .Simple }), + .lua_url = fd(2, .String), + .HJPAPNPPNNH = fd(935, .String), + .CDHOIAAONHD = fd(1386, .{ .Varint = .Simple }), + .DHKIEGBPJML = fd(1818, .String), + .region_name = fd(10, .String), + .OMDAJOMPIMG = fd(1188, .String), + .KFIGINFCAKM = fd(1069, .String), + .FPHMEDIMIOB = fd(1274, .String), + .GOELMBPGOFC = fd(1006, .{ .Varint = .Simple }), + .MCANJEHAEKO = fd(6, .{ .Varint = .Simple }), + .ifix_version = fd(1209, .String), + .KJOPNFNPOML = fd(1895, .String), + .CIKOEPDNJBA = fd(75, .String), + .DIECBLIJNPO = fd(387, .String), + .FEJLKGFLMNF = fd(1690, .String), + .ex_resource_url = fd(14, .String), + .CIGLGHGDBHB = fd(462, .String), + .GAHDEBODOPK = fd(1609, .String), + .ip = fd(1, .String), + .AGMKEMOJHHJ = fd(11, .{ .Varint = .Simple }), + .KDGOBNKMNKC = fd(9, .{ .Varint = .Simple }), + .msg = fd(7, .String), + .GEBNKMIPOMM = fd(989, .{ .Varint = .Simple }), + .EBNBNCHNOFH = fd(4, .String), + .GLCOMFKHDGH = fd(929, .String), + .GECDDMDAGCL = fd(1226, .String), + .FABJDGBFAFF = fd(512, .String), + .use_tcp = fd(1359, .{ .Varint = .Simple }), + .JPGHOAAFODJ = fd(194, .String), + .BKMDGECDJLJ = fd(2007, .String), + .CCFBLAONHAF = fd(350, .{ .Varint = .Simple }), + .FKFKCDJNHFL = fd(1401, .{ .Varint = .Simple }), + .MFENPHLEGHJ = fd(1537, .{ .Varint = .Simple }), + .MFFMCCGBHBJ = fd(889, .{ .Varint = .Simple }), + .FOPDCGLBOOI = fd(1470, .String), + .GNFPFKJHIDJ = fd(1037, .{ .Varint = .Simple }), + .LHKJHDCIDND = fd(886, .String), + .ALNIFJLCIJJ = fd(1783, .String), + .AGEBFKODEAE = fd(616, .String), + .client_secret_key = fd(1597, .String), + .NNPPEAAIHAK = fd(82, .{ .Varint = .Simple }), + .PAIINFFIDLH = fd(452, .{ .Varint = .Simple }), + .PGMFEHFKLBG = fd(13, .{ .Varint = .Simple }), + .NCDIJNHGELK = fd(8, .{ .Varint = .Simple }), + .lua_version = fd(1798, .String), + .NMKHBELIAOK = fd(1613, .String), + .ALEILJPDNFF = fd(692, .String), + .OFGPAONJADM = fd(5, .{ .Varint = .Simple }), + .port = fd(12, .{ .Varint = .Simple }), + .asset_bundle_url = fd(15, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDKHDANPJEA = struct { + APPOLHIPFIH: ManagedString = .Empty, + + pub const _desc_table = .{ + .APPOLHIPFIH = fd(14, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PDLCDMEPDDJ = struct { + KBEJIBADOKJ: u32 = 0, + avatar_id: MultiPathAvatarType = @enumFromInt(0), + FKDENBOKHPO: ArrayList(AvatarSkillTree), + HLPGKBDIEHL: ArrayList(EquipRelic), + CHPFJFOCNJN: ArrayList(AvatarSkillTree), + rank: u32 = 0, + LGAIOPBNEPN: ArrayList(u32), + + pub const _desc_table = .{ + .KBEJIBADOKJ = fd(9, .{ .Varint = .Simple }), + .avatar_id = fd(11, .{ .Varint = .Simple }), + .FKDENBOKHPO = fd(5, .{ .List = .{ .SubMessage = {} } }), + .HLPGKBDIEHL = fd(13, .{ .List = .{ .SubMessage = {} } }), + .CHPFJFOCNJN = fd(14, .{ .List = .{ .SubMessage = {} } }), + .rank = fd(12, .{ .Varint = .Simple }), + .LGAIOPBNEPN = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetAvatarPathCsReq = struct { + avatar_id: MultiPathAvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetAvatarPathScRsp = struct { + avatar_id: MultiPathAvatarType = @enumFromInt(0), + retcode: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(9, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetMultiPathAvatarInfoCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetMultiPathAvatarInfoScRsp = struct { + retcode: u32 = 0, + HKNADMABCGG: ArrayList(PDLCDMEPDDJ), + FIFIBNJEIGL: ArrayList(FIFIBNJEIGLEntry), + GMHDHIMDKFI: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .HKNADMABCGG = fd(13, .{ .List = .{ .SubMessage = {} } }), + .FIFIBNJEIGL = fd(4, .{ .List = .{ .SubMessage = {} } }), + .GMHDHIMDKFI = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub const FIFIBNJEIGLEntry = struct { + key: u32 = 0, + value: MultiPathAvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const UnlockAvatarPathCsReq = struct { + avatar_id: MultiPathAvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const UnlockAvatarPathScRsp = struct { + GMHDHIMDKFI: ArrayList(u32), + retcode: u32 = 0, + avatar_id: MultiPathAvatarType = @enumFromInt(0), + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .GMHDHIMDKFI = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(8, .{ .Varint = .Simple }), + .avatar_id = fd(6, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFFEIGOPCKC = struct { + LLNDJJHPKHG: MultiPathAvatarType = @enumFromInt(0), + base_avatar_id: u32 = 0, + + pub const _desc_table = .{ + .LLNDJJHPKHG = fd(9, .{ .Varint = .Simple }), + .base_avatar_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LAFFEFHDGAG = struct { + HLHOOMICLJE: Gender = @enumFromInt(0), + + pub const _desc_table = .{ + .HLHOOMICLJE = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKGFNHEMPCN = struct { + FDOALODDFLD: MultiPathAvatarType = @enumFromInt(0), + retcode: u32 = 0, + + pub const _desc_table = .{ + .FDOALODDFLD = fd(1, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJEJLDGKELE = struct { + nickname: ManagedString = .Empty, + is_modify: bool = false, + HLHOOMICLJE: Gender = @enumFromInt(0), + + pub const _desc_table = .{ + .nickname = fd(5, .String), + .is_modify = fd(7, .{ .Varint = .Simple }), + .HLHOOMICLJE = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMPPCENAHPB = struct { + LBLMBAEBPBN: i64 = 0, + FDOALODDFLD: MultiPathAvatarType = @enumFromInt(0), + is_modify: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LBLMBAEBPBN = fd(6, .{ .Varint = .Simple }), + .FDOALODDFLD = fd(12, .{ .Varint = .Simple }), + .is_modify = fd(2, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHNNABANJFO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOFFKNAPGOM = struct { + KNFOKOAOGJH: ProductGiftType = @enumFromInt(0), + JGOFENPOJJI: ManagedString = .Empty, + JBEFEAHCJDM: u32 = 0, + PDLIGIAGJLJ: ManagedString = .Empty, + PNFMFLEHKFG: u32 = 0, + AFIPAJBMBGL: bool = false, + + pub const _desc_table = .{ + .KNFOKOAOGJH = fd(9, .{ .Varint = .Simple }), + .JGOFENPOJJI = fd(13, .String), + .JBEFEAHCJDM = fd(11, .{ .Varint = .Simple }), + .PDLIGIAGJLJ = fd(3, .String), + .PNFMFLEHKFG = fd(2, .{ .Varint = .Simple }), + .AFIPAJBMBGL = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJHCADKOLOH = struct { + DHDAENPMKOO: ArrayList(DOFFKNAPGOM), + OGLKEBKFNNK: u32 = 0, + ANMKBJHMKGC: u64 = 0, + BDDKLNCEJOE: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DHDAENPMKOO = fd(8, .{ .List = .{ .SubMessage = {} } }), + .OGLKEBKFNNK = fd(2, .{ .Varint = .Simple }), + .ANMKBJHMKGC = fd(12, .{ .Varint = .Simple }), + .BDDKLNCEJOE = fd(9, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAEBKGBNFGB = struct { + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ClientDownloadDataScNotify = struct { + download_data: ?ClientDownloadData = null, + + pub const _desc_table = .{ + .download_data = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMLGLJKMOLD = struct { + data: ?ClientObjDownloadData = null, + + pub const _desc_table = .{ + .data = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const UpdateFeatureSwitchScNotify = struct { + switch_info_list: ArrayList(FeatureSwitchInfo), + + pub const _desc_table = .{ + .switch_info_list = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKADLIGKNPC = struct { + KLKLABGGBIA: u32 = 0, + + pub const _desc_table = .{ + .KLKLABGGBIA = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBMFLIBMJLI = struct { + MEKNEGIGAHI: u32 = 0, + + pub const _desc_table = .{ + .MEKNEGIGAHI = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOAIOKMFACO = struct { + MEKNEGIGAHI: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MEKNEGIGAHI = fd(11, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EEFPHPGNBJP = struct { + FMBKGMECHCA: u32 = 0, + GBFDGCOPEDO: ManagedString = .Empty, + + pub const _desc_table = .{ + .FMBKGMECHCA = fd(12, .{ .Varint = .Simple }), + .GBFDGCOPEDO = fd(13, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DKCOPICLEKF = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFGFFEGDCCC = struct { + EFFADKJLPPN: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .EFFADKJLPPN = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerHeartBeatCsReq = struct { + client_time_ms: u64 = 0, + LLMKGPAIPKG: u32 = 0, + upload_data: ?ClientUploadData = null, + + pub const _desc_table = .{ + .client_time_ms = fd(10, .{ .Varint = .Simple }), + .LLMKGPAIPKG = fd(14, .{ .Varint = .Simple }), + .upload_data = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PlayerHeartBeatScRsp = struct { + server_time_ms: u64 = 0, + client_time_ms: u64 = 0, + retcode: u32 = 0, + download_data: ?ClientDownloadData = null, + + pub const _desc_table = .{ + .server_time_ms = fd(15, .{ .Varint = .Simple }), + .client_time_ms = fd(11, .{ .Varint = .Simple }), + .retcode = fd(1, .{ .Varint = .Simple }), + .download_data = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGADBHGGKHL = struct { + HEPOBAPLHCO: FeatureSwitchType = @enumFromInt(0), + + pub const _desc_table = .{ + .HEPOBAPLHCO = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFNMBKHNKKM = struct { + DJNLELPPHJI: ManagedString = .Empty, + EEOLCCFMJFF: SecretKeyType = @enumFromInt(0), + + pub const _desc_table = .{ + .DJNLELPPHJI = fd(12, .String), + .EEOLCCFMJFF = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDBBINLCMBK = struct { + ODIAKLJNLJC: ManagedString = .Empty, + + pub const _desc_table = .{ + .ODIAKLJNLJC = fd(3, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGFPNAPILDN = struct { + retcode: u32 = 0, + KAMOMBBJKDO: ManagedString = .Empty, + GLAGAPJDLFN: ArrayList(AFNMBKHNKKM), + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .KAMOMBBJKDO = fd(12, .String), + .GLAGAPJDLFN = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDIKNPIFPJL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IBLPCGAAFIG = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLKGOEDJAEL = struct { + id: u32 = 0, + AJAHOCHAMMK: u64 = 0, + + pub const _desc_table = .{ + .id = fd(13, .{ .Varint = .Simple }), + .AJAHOCHAMMK = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KILMAMDIIOG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCMDIMNBIKJ = struct { + retcode: u32 = 0, + EHGJICMEOGF: ArrayList(JLKGOEDJAEL), + KDLLNFMGNGK: ArrayList(JLKGOEDJAEL), + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .EHGJICMEOGF = fd(13, .{ .List = .{ .SubMessage = {} } }), + .KDLLNFMGNGK = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALLNGMEDPMD = struct { + JGMIDHMLNFK: u32 = 0, + DFGNMBNLMJI: u32 = 0, + MEGPGABOOHD: u32 = 0, + GMIGBLFHHAO: u32 = 0, + + pub const _desc_table = .{ + .JGMIDHMLNFK = fd(8, .{ .Varint = .Simple }), + .DFGNMBNLMJI = fd(7, .{ .Varint = .Simple }), + .MEGPGABOOHD = fd(6, .{ .Varint = .Simple }), + .GMIGBLFHHAO = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IDBGAPAHGHH = struct { + uid: u32 = 0, + JGMIDHMLNFK: u32 = 0, + DFGNMBNLMJI: u32 = 0, + NBFOOFHBOPC: ArrayList(ALLNGMEDPMD), + GMIGBLFHHAO: u32 = 0, + + pub const _desc_table = .{ + .uid = fd(6, .{ .Varint = .Simple }), + .JGMIDHMLNFK = fd(12, .{ .Varint = .Simple }), + .DFGNMBNLMJI = fd(11, .{ .Varint = .Simple }), + .NBFOOFHBOPC = fd(14, .{ .List = .{ .SubMessage = {} } }), + .GMIGBLFHHAO = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJNLMGJEFHE = struct { + NHFGFOCFGCG: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ReserveStaminaExchangeScRsp = struct { + num: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .num = fd(13, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIEJAAOFNFB = struct { + DELJCPLOFBK: i64 = 0, + CKCACBFEIBF: u32 = 0, + stamina: u32 = 0, + KJBIGAFDDAO: i64 = 0, + + pub const _desc_table = .{ + .DELJCPLOFBK = fd(11, .{ .Varint = .Simple }), + .CKCACBFEIBF = fd(12, .{ .Varint = .Simple }), + .stamina = fd(2, .{ .Varint = .Simple }), + .KJBIGAFDDAO = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAOLBOHJHJP = struct { + FOKLJKEEIPN: bool = false, + LFEBNOLONGM: bool = false, + NLDNPGELJMG: bool = false, + DAFHJJEDMOF: bool = false, + KDAKDMCGFND: bool = false, + BPELFJGIJID: bool = false, + EPMCKMCDIGB: JLMBAEKILPG = @enumFromInt(0), + DKLJGCEHPJL: bool = false, + KEACGBKOFKF: bool = false, + LFGHGADKHPD: bool = false, + + pub const _desc_table = .{ + .FOKLJKEEIPN = fd(9, .{ .Varint = .Simple }), + .LFEBNOLONGM = fd(13, .{ .Varint = .Simple }), + .NLDNPGELJMG = fd(12, .{ .Varint = .Simple }), + .DAFHJJEDMOF = fd(6, .{ .Varint = .Simple }), + .KDAKDMCGFND = fd(4, .{ .Varint = .Simple }), + .BPELFJGIJID = fd(14, .{ .Varint = .Simple }), + .EPMCKMCDIGB = fd(10, .{ .Varint = .Simple }), + .DKLJGCEHPJL = fd(2, .{ .Varint = .Simple }), + .KEACGBKOFKF = fd(1, .{ .Varint = .Simple }), + .LFGHGADKHPD = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHGNOMBMJBJ = struct { + MALDLNBOPHD: ?KAOLBOHJHJP = null, + + pub const _desc_table = .{ + .MALDLNBOPHD = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLKJOIMHMND = struct { + MALDLNBOPHD: ?KAOLBOHJHJP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MALDLNBOPHD = fd(6, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPEAKJJFFJN = struct { + LLMKGPAIPKG: u32 = 0, + upload_data: ManagedString = .Empty, + + pub const _desc_table = .{ + .LLMKGPAIPKG = fd(3, .{ .Varint = .Simple }), + .upload_data = fd(11, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHFBCIDLKCC = struct { + data: ?ClientObjDownloadData = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .data = fd(8, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKBGBHMMIDP = struct { + BACKBEDGIJA: ArrayList(ManagedString), + + pub const _desc_table = .{ + .BACKBEDGIJA = fd(2, .{ .List = .String }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EKJOBFKOMIE = struct { + EEPOKPJHHHB: bool = false, + EGIPFDNKCCN: ?GKBGBHMMIDP = null, + + pub const _desc_table = .{ + .EEPOKPJHHHB = fd(14, .{ .Varint = .Simple }), + .EGIPFDNKCCN = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFBHJBGHHDO = struct { + EEPOKPJHHHB: bool = false, + KIGJKDGNOPJ: ?GKBGBHMMIDP = null, + GGOPPAFGGDD: ?GKBGBHMMIDP = null, + + pub const _desc_table = .{ + .EEPOKPJHHHB = fd(1352, .{ .Varint = .Simple }), + .KIGJKDGNOPJ = fd(873, .{ .SubMessage = {} }), + .GGOPPAFGGDD = fd(1810, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DPDCKJKKEHH = struct { + PNJCIINPILL: ?EKJOBFKOMIE = null, + DDHKNBKPEJO: ?KFBHJBGHHDO = null, + + pub const _desc_table = .{ + .PNJCIINPILL = fd(741, .{ .SubMessage = {} }), + .DDHKNBKPEJO = fd(1350, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIDHIEAOCHK = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPMIAKFMLDB = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAFDOLGIGBA = struct { + avatar_id: u32 = 0, + pos: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(13, .{ .Varint = .Simple }), + .pos = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHKLJBJKELO = struct { + NFOMHJJCBMF: bool = false, + MOHDEEDFNPP: ArrayList(KAFDOLGIGBA), + + pub const _desc_table = .{ + .NFOMHJJCBMF = fd(13, .{ .Varint = .Simple }), + .MOHDEEDFNPP = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODBKGAHLDEK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJBLODBCBOC = struct { + OLAAENKMJIN: ArrayList(u32), + NELILIHJJLI: ?OHKLJBJKELO = null, + AFHIBMBDIFB: ArrayList(NPMIAKFMLDB), + NCLKEHNDEGM: u32 = 0, + MDDDOKFINDH: ManagedString = .Empty, + retcode: u32 = 0, + + pub const _desc_table = .{ + .OLAAENKMJIN = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .NELILIHJJLI = fd(10, .{ .SubMessage = {} }), + .AFHIBMBDIFB = fd(1, .{ .List = .{ .SubMessage = {} } }), + .NCLKEHNDEGM = fd(8, .{ .Varint = .Simple }), + .MDDDOKFINDH = fd(12, .String), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNAOKBFMGLA = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDLBLJEOBLE = struct { + NCLKEHNDEGM: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NCLKEHNDEGM = fd(2, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMJDLMFCKHL = struct { + MOHDEEDFNPP: ArrayList(KAFDOLGIGBA), + + pub const _desc_table = .{ + .MOHDEEDFNPP = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGBAHBEADDO = struct { + MOHDEEDFNPP: ArrayList(KAFDOLGIGBA), + retcode: u32 = 0, + + pub const _desc_table = .{ + .MOHDEEDFNPP = fd(2, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLAKGMMJBMI = struct { + NFOMHJJCBMF: bool = false, + + pub const _desc_table = .{ + .NFOMHJJCBMF = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFEPLNCHAPP = struct { + NFOMHJJCBMF: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NFOMHJJCBMF = fd(7, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGJDMHDFEOG = struct { + MDDDOKFINDH: ManagedString = .Empty, + + pub const _desc_table = .{ + .MDDDOKFINDH = fd(14, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGBPJBNAKIN = struct { + MDDDOKFINDH: ManagedString = .Empty, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MDDDOKFINDH = fd(7, .String), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AMEKOCLAOKC = struct { + avatar_id: u32 = 0, + avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .avatar_id = fd(2, .{ .Varint = .Simple }), + .avatar_id_list = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FNHGJLIPNDK = struct { + retcode: u32 = 0, + avatar_id: u32 = 0, + avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .avatar_id = fd(9, .{ .Varint = .Simple }), + .avatar_id_list = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEHAKLLLKGG = struct { + MOMAMBGKIPB: u32 = 0, + + pub const _desc_table = .{ + .MOMAMBGKIPB = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HJBBMCKPKJK = struct { + BCEOCGLIOCO: ArrayList(u32), + GHNMIGGIPIB: u32 = 0, + + pub const _desc_table = .{ + .BCEOCGLIOCO = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .GHNMIGGIPIB = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJJDEAMNNFA = struct { + retcode: u32 = 0, + BCEOCGLIOCO: ArrayList(u32), + GHNMIGGIPIB: u32 = 0, + HINOOHPAPBD: ArrayList(ItemList), + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .BCEOCGLIOCO = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .GHNMIGGIPIB = fd(9, .{ .Varint = .Simple }), + .HINOOHPAPBD = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EEGEKGAJADE = struct { + OKGJGNDJIDE: u32 = 0, + + pub const _desc_table = .{ + .OKGJGNDJIDE = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGCOEEDCHFN = struct { + CJCICLFMGOF: u32 = 0, + ECMMEIIDCDG: u32 = 0, + + pub const _desc_table = .{ + .CJCICLFMGOF = fd(4, .{ .Varint = .Simple }), + .ECMMEIIDCDG = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCPCCMBOGCK = struct { + CJCICLFMGOF: u32 = 0, + KAIIEJMCEGC: ?ItemList = null, + retcode: u32 = 0, + ECMMEIIDCDG: u32 = 0, + + pub const _desc_table = .{ + .CJCICLFMGOF = fd(9, .{ .Varint = .Simple }), + .KAIIEJMCEGC = fd(10, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + .ECMMEIIDCDG = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBNNKHEFBNJ = struct { + DDMHOKOAAIH: u32 = 0, + + pub const _desc_table = .{ + .DDMHOKOAAIH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJIJGMGCLOM = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANLPKDGKOMM = struct { + DDMHOKOAAIH: u32 = 0, + + pub const _desc_table = .{ + .DDMHOKOAAIH = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NECCKKHPKHL = struct { + BAFKEBMDFJI: i64 = 0, + OKGJGNDJIDE: u32 = 0, + status: LDMJPFCLMJI = @enumFromInt(0), + LMLFKFKJEEB: i64 = 0, + MDCILIGHIJF: ArrayList(u32), + MFMJBFAKDOI: u32 = 0, + MBEDCLKGPEA: bool = false, + BCEOCGLIOCO: ArrayList(u32), + CPOEBIBICDE: u32 = 0, + + pub const _desc_table = .{ + .BAFKEBMDFJI = fd(12, .{ .Varint = .Simple }), + .OKGJGNDJIDE = fd(6, .{ .Varint = .Simple }), + .status = fd(9, .{ .Varint = .Simple }), + .LMLFKFKJEEB = fd(3, .{ .Varint = .Simple }), + .MDCILIGHIJF = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .MFMJBFAKDOI = fd(8, .{ .Varint = .Simple }), + .MBEDCLKGPEA = fd(11, .{ .Varint = .Simple }), + .BCEOCGLIOCO = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .CPOEBIBICDE = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCCCDMEDION = struct { + retcode: u32 = 0, + MHIGABHBBEO: u32 = 0, + LBHJJGNDEAF: ?NECCKKHPKHL = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .MHIGABHBBEO = fd(4, .{ .Varint = .Simple }), + .LBHJJGNDEAF = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IEBAOPAHGEJ = struct { + LBHJJGNDEAF: ?NECCKKHPKHL = null, + + pub const _desc_table = .{ + .LBHJJGNDEAF = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IIOFIIKOFGB = struct { + GNPGAMIGLNO: u32 = 0, + + pub const _desc_table = .{ + .GNPGAMIGLNO = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LBGPEGKEKNL = struct { + retcode: u32 = 0, + GNPGAMIGLNO: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .GNPGAMIGLNO = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPIFCDCDPIB = struct { + basic_info: ?OCNJNNJAMCG = null, + JGBGIKPBLFP: u32 = 0, + CENDPDCDNGP: ?LMDAMMAFNEN = null, + ICCJJBMEPMM: PunkLordAttackerStatus = @enumFromInt(0), + + pub const _desc_table = .{ + .basic_info = fd(11, .{ .SubMessage = {} }), + .JGBGIKPBLFP = fd(14, .{ .Varint = .Simple }), + .CENDPDCDNGP = fd(4, .{ .SubMessage = {} }), + .ICCJJBMEPMM = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMBEGMGGNJC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLJMDJCOMOI = struct { + retcode: u32 = 0, + HGHNJPGLKAG: ArrayList(PPIFCDCDPIB), + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .HGHNJPGLKAG = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMOJDJAEIJI = struct { + CJKCOJJMOCI: bool = false, + uid: u32 = 0, + monster_id: u32 = 0, + + pub const _desc_table = .{ + .CJKCOJJMOCI = fd(13, .{ .Varint = .Simple }), + .uid = fd(1, .{ .Varint = .Simple }), + .monster_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDCEFJNCCMP = struct { + LPOJMENELGK: i64 = 0, + KMHGFOEBOJK: ArrayList(u32), + HEGMDFLEEOE: ?PPIFCDCDPIB = null, + retcode: u32 = 0, + CJKCOJJMOCI: bool = false, + + pub const _desc_table = .{ + .LPOJMENELGK = fd(3, .{ .Varint = .Simple }), + .KMHGFOEBOJK = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .HEGMDFLEEOE = fd(15, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + .CJKCOJJMOCI = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFAEGPGLKEM = struct { + uid: u32 = 0, + monster_id: u32 = 0, + NGFEEBAEKAM: PunkLordShareType = @enumFromInt(0), + + pub const _desc_table = .{ + .uid = fd(4, .{ .Varint = .Simple }), + .monster_id = fd(3, .{ .Varint = .Simple }), + .NGFEEBAEKAM = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GALFGJPDKBO = struct { + NGFEEBAEKAM: PunkLordShareType = @enumFromInt(0), + retcode: u32 = 0, + uid: u32 = 0, + monster_id: u32 = 0, + + pub const _desc_table = .{ + .NGFEEBAEKAM = fd(12, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .uid = fd(3, .{ .Varint = .Simple }), + .monster_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGHPLMLFNPB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFIANGDJPLC = struct { + retcode: u32 = 0, + HEGMDFLEEOE: ?PPIFCDCDPIB = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .HEGMDFLEEOE = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGBANEJFNHL = struct { + HFEDJFGPNOH: bool = false, + level: u32 = 0, + + pub const _desc_table = .{ + .HFEDJFGPNOH = fd(14, .{ .Varint = .Simple }), + .level = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LKLFIHCJPCF = struct { + level: u32 = 0, + HFEDJFGPNOH: bool = false, + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .level = fd(15, .{ .Varint = .Simple }), + .HFEDJFGPNOH = fd(14, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(3, .{ .SubMessage = {} }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLFAECCJAOH = struct { + basic_info: ?OCNJNNJAMCG = null, + CENDPDCDNGP: ?PunkLordBattleRecord = null, + NLEFHGHGKPE: PunkLordMonsterInfoNotifyReason = @enumFromInt(0), + KMHGFOEBOJK: ArrayList(u32), + + pub const _desc_table = .{ + .basic_info = fd(12, .{ .SubMessage = {} }), + .CENDPDCDNGP = fd(15, .{ .SubMessage = {} }), + .NLEFHGHGKPE = fd(3, .{ .Varint = .Simple }), + .KMHGFOEBOJK = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JFONEADKLHE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const INMOEEEIHAE = struct { + PCHNKJDMAAO: ArrayList(u32), + BOGLNNPOFJB: i64 = 0, + DNOGJEIEALE: u32 = 0, + CCIPPBFDMCH: u32 = 0, + OHJNEMLCGNP: u32 = 0, + retcode: u32 = 0, + OPOLFABOOAF: u32 = 0, + CDHLGDNJGBC: u32 = 0, + + pub const _desc_table = .{ + .PCHNKJDMAAO = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .BOGLNNPOFJB = fd(3, .{ .Varint = .Simple }), + .DNOGJEIEALE = fd(9, .{ .Varint = .Simple }), + .CCIPPBFDMCH = fd(13, .{ .Varint = .Simple }), + .OHJNEMLCGNP = fd(15, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .OPOLFABOOAF = fd(11, .{ .Varint = .Simple }), + .CDHLGDNJGBC = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPCGMEMCKCD = struct { + HEGMDFLEEOE: ?OCNJNNJAMCG = null, + + pub const _desc_table = .{ + .HEGMDFLEEOE = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGOBPBGKIBC = struct { + KDHANCCDGMB: u32 = 0, + MJKOPOKGMNH: u32 = 0, + CENDPDCDNGP: ?PunkLordBattleRecord = null, + LMEDPAKEJCK: u32 = 0, + HEGMDFLEEOE: ?OCNJNNJAMCG = null, + + pub const _desc_table = .{ + .KDHANCCDGMB = fd(6, .{ .Varint = .Simple }), + .MJKOPOKGMNH = fd(7, .{ .Varint = .Simple }), + .CENDPDCDNGP = fd(5, .{ .SubMessage = {} }), + .LMEDPAKEJCK = fd(2, .{ .Varint = .Simple }), + .HEGMDFLEEOE = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPGMNGFALPF = struct { + DGFLHAEFBEP: u32 = 0, + monster_id: u32 = 0, + KNACMDEJFAF: bool = false, + FADGPBGDLBG: i64 = 0, + world_level: u32 = 0, + EIDPECKNMCH: u32 = 0, + + pub const _desc_table = .{ + .DGFLHAEFBEP = fd(1, .{ .Varint = .Simple }), + .monster_id = fd(12, .{ .Varint = .Simple }), + .KNACMDEJFAF = fd(6, .{ .Varint = .Simple }), + .FADGPBGDLBG = fd(13, .{ .Varint = .Simple }), + .world_level = fd(14, .{ .Varint = .Simple }), + .EIDPECKNMCH = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPJPNJJCDMJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFKLCMFPNJG = struct { + OFNBCKLJPCB: ArrayList(GFNPGIEFEIG), + retcode: u32 = 0, + AKMJHOLABNG: ArrayList(PPGMNGFALPF), + + pub const _desc_table = .{ + .OFNBCKLJPCB = fd(13, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(7, .{ .Varint = .Simple }), + .AKMJHOLABNG = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GPBPOJLIHBN = struct { + HJBMOKCNEEB: ?PPGMNGFALPF = null, + + pub const _desc_table = .{ + .HJBMOKCNEEB = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEMJDNFIALH = struct { + OCNMPMBDMLJ: bool = false, + CLBLAAMFBLK: ?GFNPGIEFEIG = null, + + pub const _desc_table = .{ + .OCNMPMBDMLJ = fd(7, .{ .Varint = .Simple }), + .CLBLAAMFBLK = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NNEMCONOACP = struct { + FDDOLEGBPHH: u32 = 0, + retcode: u32 = 0, + OCNMPMBDMLJ: bool = false, + FDLEJIPCDDJ: ArrayList(GFNPGIEFEIG), + + pub const _desc_table = .{ + .FDDOLEGBPHH = fd(5, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + .OCNMPMBDMLJ = fd(10, .{ .Varint = .Simple }), + .FDLEJIPCDDJ = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFHJJIBHCGC = struct { + DNOGJEIEALE: u32 = 0, + CCIPPBFDMCH: u32 = 0, + OPOLFABOOAF: u32 = 0, + + pub const _desc_table = .{ + .DNOGJEIEALE = fd(12, .{ .Varint = .Simple }), + .CCIPPBFDMCH = fd(8, .{ .Varint = .Simple }), + .OPOLFABOOAF = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOCEGCFFJDO = struct { + CLBLAAMFBLK: ?GFNPGIEFEIG = null, + + pub const _desc_table = .{ + .CLBLAAMFBLK = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MHIHHHDBNKI = struct { + retcode: u32 = 0, + DOJCMLKIDIB: ArrayList(PunkLordBattleRecord), + IBPHOFIBLLM: ArrayList(PunkLordBattleReplay), + CLBLAAMFBLK: ?GFNPGIEFEIG = null, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .DOJCMLKIDIB = fd(13, .{ .List = .{ .SubMessage = {} } }), + .IBPHOFIBLLM = fd(15, .{ .List = .{ .SubMessage = {} } }), + .CLBLAAMFBLK = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMAICDPIIEM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDENNNNBMNC = struct { + BAFKEBMDFJI: i64 = 0, + GECBFFCJJGJ: ArrayList(u32), + status: QuestStatus = @enumFromInt(0), + progress: u32 = 0, + id: u32 = 0, + + pub const _desc_table = .{ + .BAFKEBMDFJI = fd(4, .{ .Varint = .Simple }), + .GECBFFCJJGJ = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .status = fd(8, .{ .Varint = .Simple }), + .progress = fd(6, .{ .Varint = .Simple }), + .id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJFJHBHNADK = struct { + PNHFLNFPEOH: ArrayList(MDENNNNBMNC), + LLDHJNLGOPL: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .PNHFLNFPEOH = fd(10, .{ .List = .{ .SubMessage = {} } }), + .LLDHJNLGOPL = fd(15, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LBJIMPEFGBA = struct { + FGHHJKEJOFC: ArrayList(u32), + + pub const _desc_table = .{ + .FGHHJKEJOFC = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const TakeQuestRewardScRsp = struct { + retcode: u32 = 0, + succ_quest_id_list: ArrayList(u32), + reward: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .succ_quest_id_list = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .reward = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBAIDEDAGPA = struct { + IDONMCFMCBE: u32 = 0, + DIFJDGCBOBJ: u32 = 0, + + pub const _desc_table = .{ + .IDONMCFMCBE = fd(13, .{ .Varint = .Simple }), + .DIFJDGCBOBJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GIJBOKJPFOP = struct { + DIFJDGCBOBJ: u32 = 0, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .DIFJDGCBOBJ = fd(12, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPBNDGIFKEC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDCJBKMDMII = struct { + GHCPPNJIJOP: u32 = 0, + progress: u32 = 0, + + pub const _desc_table = .{ + .GHCPPNJIJOP = fd(3, .{ .Varint = .Simple }), + .progress = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBPDKLLPMHF = struct { + retcode: u32 = 0, + EHMOJOHOPAL: ArrayList(HDCJBKMDMII), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .EHMOJOHOPAL = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DENBAMKEHOP = struct { + MLFJIEPPPCO: ?HDCJBKMDMII = null, + + pub const _desc_table = .{ + .MLFJIEPPPCO = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFIADKLDGNC = struct { + prop_id: u32 = 0, + group_id: u32 = 0, + DIFJDGCBOBJ: u32 = 0, + + pub const _desc_table = .{ + .prop_id = fd(9, .{ .Varint = .Simple }), + .group_id = fd(11, .{ .Varint = .Simple }), + .DIFJDGCBOBJ = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EINHGBGKIGL = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHFICOEDILI = struct { + PNHFLNFPEOH: ArrayList(u32), + + pub const _desc_table = .{ + .PNHFLNFPEOH = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMNFDEPOCAO = struct { + retcode: u32 = 0, + PNHFLNFPEOH: ArrayList(MDENNNNBMNC), + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .PNHFLNFPEOH = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDHKMCAJNKL = struct { + HAPEGHIPNGA: u32 = 0, + world_level: u32 = 0, + GGFPCDONOFJ: u32 = 0, + prop_entity_id: u32 = 0, + avatar_list: ArrayList(u32), + + pub const _desc_table = .{ + .HAPEGHIPNGA = fd(9, .{ .Varint = .Simple }), + .world_level = fd(13, .{ .Varint = .Simple }), + .GGFPCDONOFJ = fd(12, .{ .Varint = .Simple }), + .prop_entity_id = fd(15, .{ .Varint = .Simple }), + .avatar_list = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APDFDONBNLA = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJMMKNONLCD = struct { + HAPEGHIPNGA: bool = false, + GGFPCDONOFJ: u32 = 0, + + pub const _desc_table = .{ + .HAPEGHIPNGA = fd(15, .{ .Varint = .Simple }), + .GGFPCDONOFJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFBOPGPGJLJ = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJHIMKBFPIA = struct { + HEEEMJFAALF: DENNPFNEMIF = @enumFromInt(0), + FGICLIAGNIN: u32 = 0, + GJAPMAIEAAI: u32 = 0, + + pub const _desc_table = .{ + .HEEEMJFAALF = fd(8, .{ .Varint = .Simple }), + .FGICLIAGNIN = fd(3, .{ .Varint = .Simple }), + .GJAPMAIEAAI = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFOKKGHBPNC = struct { + GGFPCDONOFJ: u32 = 0, + status: RaidStatus = @enumFromInt(0), + world_level: u32 = 0, + DFKBAOMMLEI: ArrayList(CJHIMKBFPIA), + LHFFLOKIELE: ?ItemList = null, + HCMPCDPBGKI: u64 = 0, + + pub const _desc_table = .{ + .GGFPCDONOFJ = fd(4, .{ .Varint = .Simple }), + .status = fd(2, .{ .Varint = .Simple }), + .world_level = fd(1, .{ .Varint = .Simple }), + .DFKBAOMMLEI = fd(10, .{ .List = .{ .SubMessage = {} } }), + .LHFFLOKIELE = fd(11, .{ .SubMessage = {} }), + .HCMPCDPBGKI = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IGJBEEIIICA = struct { + GGFPCDONOFJ: u32 = 0, + FOGBECBDFDM: u32 = 0, + + pub const _desc_table = .{ + .GGFPCDONOFJ = fd(5, .{ .Varint = .Simple }), + .FOGBECBDFDM = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFNNDMADCCK = struct { + GNPFLMJPJLK: ArrayList(u32), + GGFPCDONOFJ: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .GNPFLMJPJLK = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .GGFPCDONOFJ = fd(9, .{ .Varint = .Simple }), + .world_level = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEHLLOHPJMD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetRaidInfoScRsp = struct { + challenge_taken_reward_id_list: ArrayList(u32), + finished_raid_info_list: ArrayList(CFNNDMADCCK), + challenge_raid_list: ArrayList(IGJBEEIIICA), + retcode: u32 = 0, + + pub const _desc_table = .{ + .challenge_taken_reward_id_list = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .finished_raid_info_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + .challenge_raid_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOABDJFFIBM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFNMILEGNIJ = struct { + GHACPIDJGJB: ArrayList(IGJBEEIIICA), + MHHNGINCLLE: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .GHACPIDJGJB = fd(11, .{ .List = .{ .SubMessage = {} } }), + .MHHNGINCLLE = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCLGCCFKLLP = struct { + AFDMMKICBCK: u32 = 0, + + pub const _desc_table = .{ + .AFDMMKICBCK = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNOIMOMAFJC = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + AFDMMKICBCK: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(13, .{ .SubMessage = {} }), + .retcode = fd(6, .{ .Varint = .Simple }), + .AFDMMKICBCK = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLDBJMAGKAP = struct { + FGKIDCMNDCG: ?IGJBEEIIICA = null, + + pub const _desc_table = .{ + .FGKIDCMNDCG = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLNIEJLJLDA = struct { + progress: u32 = 0, + BFDNDBPPEOL: u32 = 0, + + pub const _desc_table = .{ + .progress = fd(8, .{ .Varint = .Simple }), + .BFDNDBPPEOL = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMHHEOIPCDC = struct { + progress: u32 = 0, + retcode: u32 = 0, + BFDNDBPPEOL: u32 = 0, + + pub const _desc_table = .{ + .progress = fd(11, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + .BFDNDBPPEOL = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CCIKLCIBAHC = struct { + GGFPCDONOFJ: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .GGFPCDONOFJ = fd(15, .{ .Varint = .Simple }), + .world_level = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPDAJDCFJBK = struct { + DFKBAOMMLEI: ArrayList(CJHIMKBFPIA), + HAPEGHIPNGA: bool = false, + world_level: u32 = 0, + GGFPCDONOFJ: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DFKBAOMMLEI = fd(10, .{ .List = .{ .SubMessage = {} } }), + .HAPEGHIPNGA = fd(1, .{ .Varint = .Simple }), + .world_level = fd(5, .{ .Varint = .Simple }), + .GGFPCDONOFJ = fd(9, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMIFIGLECME = struct { + DFKBAOMMLEI: ArrayList(CJHIMKBFPIA), + GGFPCDONOFJ: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .DFKBAOMMLEI = fd(14, .{ .List = .{ .SubMessage = {} } }), + .GGFPCDONOFJ = fd(15, .{ .Varint = .Simple }), + .world_level = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNKDAEHEAPN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFOKIGLCOHB = struct { + LGBAMHOMKPE: ArrayList(PMIFIGLECME), + retcode: u32 = 0, + + pub const _desc_table = .{ + .LGBAMHOMKPE = fd(14, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CADIMDKJMLP = struct { + GGFPCDONOFJ: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .GGFPCDONOFJ = fd(9, .{ .Varint = .Simple }), + .world_level = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFDBDJPKGCO = struct { + NLEFHGHGKPE: HDHIENAJBKF = @enumFromInt(0), + world_level: u32 = 0, + lineup: ?LineupInfo = null, + GGFPCDONOFJ: u32 = 0, + scene: ?SceneInfo = null, + + pub const _desc_table = .{ + .NLEFHGHGKPE = fd(15, .{ .Varint = .Simple }), + .world_level = fd(11, .{ .Varint = .Simple }), + .lineup = fd(1, .{ .SubMessage = {} }), + .GGFPCDONOFJ = fd(3, .{ .Varint = .Simple }), + .scene = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGKLFGGGHDK = struct { + FOOBOEIKAIC: u32 = 0, + + pub const _desc_table = .{ + .FOOBOEIKAIC = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GILLBPGHJBE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIPOANCKFHC = struct { + NIKHKCMAFMM: ArrayList(JGKLFGGGHDK), + retcode: u32 = 0, + + pub const _desc_table = .{ + .NIKHKCMAFMM = fd(6, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NKKKMEMFIEJ = struct { + HLHLPCCFKNO: ?JGKLFGGGHDK = null, + + pub const _desc_table = .{ + .HLHLPCCFKNO = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LOKMFEGLCOJ = struct { + NKIFGMGKOAI: ArrayList(u32), + + pub const _desc_table = .{ + .NKIFGMGKOAI = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGFJMIBKBCL = struct { + MFNMOKNIPNN: ArrayList(MFNMOKNIPNNEntry), + ABEDIGLKNCF: u32 = 0, + BAKLBHIBADH: u32 = 0, + + pub const _desc_table = .{ + .MFNMOKNIPNN = fd(3, .{ .List = .{ .SubMessage = {} } }), + .ABEDIGLKNCF = fd(7, .{ .Varint = .Simple }), + .BAKLBHIBADH = fd(2, .{ .Varint = .Simple }), + }; + + pub const MFNMOKNIPNNEntry = struct { + key: u32 = 0, + value: ?LOKMFEGLCOJ = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IDAGGHLNCLI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKAKCFNKJMD = struct { + OMGADKMIPDB: ArrayList(CGFJMIBKBCL), + retcode: u32 = 0, + + pub const _desc_table = .{ + .OMGADKMIPDB = fd(6, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKLEGNCNEGO = struct { + group_id: u32 = 0, + CLDEJHLAHII: EJOFFDHCFDA = @enumFromInt(0), + param_list: ArrayList(u32), + ABEDIGLKNCF: u32 = 0, + BAKLBHIBADH: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(14, .{ .Varint = .Simple }), + .CLDEJHLAHII = fd(11, .{ .Varint = .Simple }), + .param_list = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .ABEDIGLKNCF = fd(13, .{ .Varint = .Simple }), + .BAKLBHIBADH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJEDOLNDCGA = struct { + ABEDIGLKNCF: u32 = 0, + BAKLBHIBADH: u32 = 0, + group_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ABEDIGLKNCF = fd(10, .{ .Varint = .Simple }), + .BAKLBHIBADH = fd(9, .{ .Varint = .Simple }), + .group_id = fd(2, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJFIJMCHDPH = struct { + group_id: u32 = 0, + ABEDIGLKNCF: u32 = 0, + BAKLBHIBADH: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(10, .{ .Varint = .Simple }), + .ABEDIGLKNCF = fd(12, .{ .Varint = .Simple }), + .BAKLBHIBADH = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONDECKHMFID = struct { + retcode: u32 = 0, + group_id: u32 = 0, + BAKLBHIBADH: u32 = 0, + DLMICLJGEPN: ?LOKMFEGLCOJ = null, + ABEDIGLKNCF: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .group_id = fd(3, .{ .Varint = .Simple }), + .BAKLBHIBADH = fd(6, .{ .Varint = .Simple }), + .DLMICLJGEPN = fd(11, .{ .SubMessage = {} }), + .ABEDIGLKNCF = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IAAAHNPEEEC = struct { + KFHJMGKBFIE: ReplayType = @enumFromInt(0), + stage_id: u32 = 0, + MGEAKFDLCOL: u32 = 0, + HOLLKMFGADB: u32 = 0, + FPNDGKINGDP: ManagedString = .Empty, + AJCJGGBFMKF: ManagedString = .Empty, + + pub const _desc_table = .{ + .KFHJMGKBFIE = fd(3, .{ .Varint = .Simple }), + .stage_id = fd(15, .{ .Varint = .Simple }), + .MGEAKFDLCOL = fd(4, .{ .Varint = .Simple }), + .HOLLKMFGADB = fd(1, .{ .Varint = .Simple }), + .FPNDGKINGDP = fd(5, .String), + .AJCJGGBFMKF = fd(11, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPAKIOMLLNB = struct { + AJCJGGBFMKF: ManagedString = .Empty, + KFHJMGKBFIE: ReplayType = @enumFromInt(0), + retcode: u32 = 0, + stage_id: u32 = 0, + DHDMABNFKBM: ManagedString = .Empty, + + pub const _desc_table = .{ + .AJCJGGBFMKF = fd(15, .String), + .KFHJMGKBFIE = fd(9, .{ .Varint = .Simple }), + .retcode = fd(3, .{ .Varint = .Simple }), + .stage_id = fd(1, .{ .Varint = .Simple }), + .DHDMABNFKBM = fd(4, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBLFMLBIIHE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFHMBDHAHPK = struct { + retcode: u32 = 0, + BFDHCIAICJO: ArrayList(CKMFNDFODKC), + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .BFDHCIAICJO = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMIMODADPMM = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDBNPEELCGB = struct { + retcode: u32 = 0, + HJMFCENCKPM: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .HJMFCENCKPM = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POBNNHICECA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDPMNLLFLFL = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOOGELPCMLN = struct { + level: u32 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .level = fd(15, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NADLMBOOGPE = struct { + buff_list: ArrayList(IOOGELPCMLN), + + pub const _desc_table = .{ + .buff_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHMFJINEGJF = struct { + HHNMDAKKDPD: u32 = 0, + MGAHHMCOGKK: u32 = 0, + GCLIKAAOKJL: RogueRoomStatus = @enumFromInt(0), + GCAAEMOFLDM: RogueRoomStatus = @enumFromInt(0), + LOPNFDJHCLN: u32 = 0, + + pub const _desc_table = .{ + .HHNMDAKKDPD = fd(1, .{ .Varint = .Simple }), + .MGAHHMCOGKK = fd(14, .{ .Varint = .Simple }), + .GCLIKAAOKJL = fd(3, .{ .Varint = .Simple }), + .GCAAEMOFLDM = fd(10, .{ .Varint = .Simple }), + .LOPNFDJHCLN = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHLHFHIJFIK = struct { + NHDDPHMIIJE: ArrayList(DHMFJINEGJF), + EFHFKOOAGKG: u32 = 0, + BMMNNBEJFCO: u32 = 0, + EGKOJHEIOHH: u32 = 0, + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .NHDDPHMIIJE = fd(4, .{ .List = .{ .SubMessage = {} } }), + .EFHFKOOAGKG = fd(2, .{ .Varint = .Simple }), + .BMMNNBEJFCO = fd(13, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(5, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PGKIOJPAPKK = struct { + IDHCLDDENHB: bool = false, + AHDIECBFBIF: u32 = 0, + ICPANMCHBKB: CKANLCGNOIL = @enumFromInt(0), + ONBDKKFHLAO: u32 = 0, + MEFCILNEJKN: RogueStatus = @enumFromInt(0), + EGKOJHEIOHH: u32 = 0, + + pub const _desc_table = .{ + .IDHCLDDENHB = fd(4, .{ .Varint = .Simple }), + .AHDIECBFBIF = fd(10, .{ .Varint = .Simple }), + .ICPANMCHBKB = fd(15, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(9, .{ .Varint = .Simple }), + .MEFCILNEJKN = fd(5, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FAIFPFPHCDE = struct { + KJCHFHECDMM: u32 = 0, + FECIKCPDPCH: u32 = 0, + ONOFKLKPHMD: u32 = 0, + MGDFKHOAJLO: ?PEHCKCFABKB = null, + JFLPLGKNNOK: ArrayList(u32), + BCFDHBFIIEB: u32 = 0, + BIGMODPHFDB: u32 = 0, + BHBCDKIMBFL: u32 = 0, + ACCGEPOBNPK: bool = false, + LLPKBHJILJN: u32 = 0, + AJMBMJDJEJJ: BMGHHGAHIIN = @enumFromInt(0), + MJFJBBEPONN: u32 = 0, + IMPBNMLGOPF: ArrayList(IOOGELPCMLN), + + pub const _desc_table = .{ + .KJCHFHECDMM = fd(11, .{ .Varint = .Simple }), + .FECIKCPDPCH = fd(15, .{ .Varint = .Simple }), + .ONOFKLKPHMD = fd(13, .{ .Varint = .Simple }), + .MGDFKHOAJLO = fd(5, .{ .SubMessage = {} }), + .JFLPLGKNNOK = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .BCFDHBFIIEB = fd(7, .{ .Varint = .Simple }), + .BIGMODPHFDB = fd(10, .{ .Varint = .Simple }), + .BHBCDKIMBFL = fd(2, .{ .Varint = .Simple }), + .ACCGEPOBNPK = fd(8, .{ .Varint = .Simple }), + .LLPKBHJILJN = fd(4, .{ .Varint = .Simple }), + .AJMBMJDJEJJ = fd(1, .{ .Varint = .Simple }), + .MJFJBBEPONN = fd(6, .{ .Varint = .Simple }), + .IMPBNMLGOPF = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGPJDPDOOEC = struct { + FIFIACFLFDL: ?IOOGELPCMLN = null, + HGBFNHKINNL: ArrayList(IOOGELPCMLN), + + pub const _desc_table = .{ + .FIFIACFLFDL = fd(4, .{ .SubMessage = {} }), + .HGBFNHKINNL = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGDAJMBAIPK = struct { + PIIINAKMKCA: ArrayList(IOOGELPCMLN), + DCECFOKFIHH: u32 = 0, + HFIBNMPNCFG: ArrayList(IOOGELPCMLN), + + pub const _desc_table = .{ + .PIIINAKMKCA = fd(14, .{ .List = .{ .SubMessage = {} } }), + .DCECFOKFIHH = fd(9, .{ .Varint = .Simple }), + .HFIBNMPNCFG = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEOHJAIHCMD = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + PABMLBGBKMK: f32 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(2, .{ .SubMessage = {} }), + .PABMLBGBKMK = fd(3, .{ .FixedInt = .I32 }), + .NOJPMGONLPN = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLNGNLAOOIP = struct { + BJNNANHPCNG: ArrayList(CEOHJAIHCMD), + + pub const _desc_table = .{ + .BJNNANHPCNG = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IBLOFNAKAPA = struct { + KABNOGFDKFI: u32 = 0, + NDPAMBJKKFD: u32 = 0, + KFIMJFGJLMM: u32 = 0, + NFNNOMAMNAA: u32 = 0, + JBFJGEIGGBA: ArrayList(JBFJGEIGGBAEntry), + + pub const _desc_table = .{ + .KABNOGFDKFI = fd(2, .{ .Varint = .Simple }), + .NDPAMBJKKFD = fd(9, .{ .Varint = .Simple }), + .KFIMJFGJLMM = fd(10, .{ .Varint = .Simple }), + .NFNNOMAMNAA = fd(12, .{ .Varint = .Simple }), + .JBFJGEIGGBA = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const JBFJGEIGGBAEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOFHBGBOFNE = struct { + BDDANOBJMEL: u32 = 0, + BAILOBNCIGP: u32 = 0, + PKCPJMCBKPB: ArrayList(IBLOFNAKAPA), + + pub const _desc_table = .{ + .BDDANOBJMEL = fd(8, .{ .Varint = .Simple }), + .BAILOBNCIGP = fd(4, .{ .Varint = .Simple }), + .PKCPJMCBKPB = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHDMJKHCOHD = struct { + NMGLMKJGANP: ArrayList(u32), + LDMGIHBCHBL: ?BOFHBGBOFNE = null, + + pub const _desc_table = .{ + .NMGLMKJGANP = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .LDMGIHBCHBL = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEBFFHJCHNO = struct { + GHJIDOPJDOM: ArrayList(u32), + + pub const _desc_table = .{ + .GHJIDOPJDOM = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CDGPDHMNMON = struct { + GHKHNNNELME: ArrayList(u32), + + pub const _desc_table = .{ + .GHKHNNNELME = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DEACDPHKHJA = struct { + BFOHFAJIFEH: u32 = 0, + IMOJCCEGMMM: ?ItemList = null, + LGBCJENOIPM: ?NADLMBOOGPE = null, + + pub const _desc_table = .{ + .BFOHFAJIFEH = fd(9, .{ .Varint = .Simple }), + .IMOJCCEGMMM = fd(11, .{ .SubMessage = {} }), + .LGBCJENOIPM = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMLAOCOIBIL = struct { + LAKLNFMHMLO: u32 = 0, + HIMNEOAEELB: ArrayList(u32), + PLLLDFLFBFA: ?PEHCKCFABKB = null, + MODHOJOGOBC: u32 = 0, + + pub const _desc_table = .{ + .LAKLNFMHMLO = fd(8, .{ .Varint = .Simple }), + .HIMNEOAEELB = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .PLLLDFLFBFA = fd(14, .{ .SubMessage = {} }), + .MODHOJOGOBC = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IALLPBIFDCH = struct { + MMFONGDIGIK: u32 = 0, + + pub const _desc_table = .{ + .MMFONGDIGIK = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCAHJEHGCKP = struct { + NOLNLHIPHKO: u32 = 0, + CLPHHMPMHMP: u32 = 0, + BIGMODPHFDB: u32 = 0, + PNONKBMMHPJ: u32 = 0, + + pub const _desc_table = .{ + .NOLNLHIPHKO = fd(8, .{ .Varint = .Simple }), + .CLPHHMPMHMP = fd(11, .{ .Varint = .Simple }), + .BIGMODPHFDB = fd(3, .{ .Varint = .Simple }), + .PNONKBMMHPJ = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GPDICDINPNF = struct { + DINGJPLIJKG: ?PPNEBKPICML = null, + BLJGIINGHIH: ?HJPBMMBNAED = null, + + pub const _desc_table = .{ + .DINGJPLIJKG = fd(653, .{ .SubMessage = {} }), + .BLJGIINGHIH = fd(1128, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPNEBKPICML = struct { + EHLLPADLJPK: ?BMEEKBBCBFK = null, + ODEHLKCFDIJ: ?HKGBAJLMHDP = null, + GKHNCIGJIBE: ?BKFIJHHLBJD = null, + JIOMIEGFHJE: ?CMHGKGFDKMD = null, + BOJFAPKEFLD: ?GCOLJFDLONK = null, + + pub const _desc_table = .{ + .EHLLPADLJPK = fd(10, .{ .SubMessage = {} }), + .ODEHLKCFDIJ = fd(3, .{ .SubMessage = {} }), + .GKHNCIGJIBE = fd(2, .{ .SubMessage = {} }), + .JIOMIEGFHJE = fd(5, .{ .SubMessage = {} }), + .BOJFAPKEFLD = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HJPBMMBNAED = struct { + JGHAOFCGEMP: ?PAOGLFPDNOA = null, + status: RogueStatus = @enumFromInt(0), + OLIBJIMDGGB: ?IBLHIDENCOG = null, + GPOIMNADJOH: bool = false, + OHCEDACENOC: ?IHLHFHIJFIK = null, + FENFEHFCGPO: ?IMIKGILFCCI = null, + LDMGIHBCHBL: ?PLCMHMNAPMA = null, + AHFPDGIGHID: ?PNGDOGDCNMI = null, + DNNNDJCADJE: ?AEFOCGBFHOP = null, + ODEHLKCFDIJ: ?NEFDLNDMHBK = null, + + pub const _desc_table = .{ + .JGHAOFCGEMP = fd(3, .{ .SubMessage = {} }), + .status = fd(12, .{ .Varint = .Simple }), + .OLIBJIMDGGB = fd(1, .{ .SubMessage = {} }), + .GPOIMNADJOH = fd(14, .{ .Varint = .Simple }), + .OHCEDACENOC = fd(7, .{ .SubMessage = {} }), + .FENFEHFCGPO = fd(13, .{ .SubMessage = {} }), + .LDMGIHBCHBL = fd(2, .{ .SubMessage = {} }), + .AHFPDGIGHID = fd(10, .{ .SubMessage = {} }), + .DNNNDJCADJE = fd(11, .{ .SubMessage = {} }), + .ODEHLKCFDIJ = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMHGKGFDKMD = struct { + begin_time: i64 = 0, + NDBJIIAIPAD: u32 = 0, + end_time: i64 = 0, + + pub const _desc_table = .{ + .begin_time = fd(6, .{ .Varint = .Simple }), + .NDBJIIAIPAD = fd(3, .{ .Varint = .Simple }), + .end_time = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GCOLJFDLONK = struct { + IPNKFJKIICA: ArrayList(PGKIOJPAPKK), + + pub const _desc_table = .{ + .IPNKFJKIICA = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HKGBAJLMHDP = struct { + EGOHCFPCLPP: bool = false, + DKMDMKCMMPN: u32 = 0, + BIHOFLAIKAP: ArrayList(u32), + FAMLMPEPBLI: u32 = 0, + + pub const _desc_table = .{ + .EGOHCFPCLPP = fd(5, .{ .Varint = .Simple }), + .DKMDMKCMMPN = fd(10, .{ .Varint = .Simple }), + .BIHOFLAIKAP = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .FAMLMPEPBLI = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKFIJHHLBJD = struct { + EPOPDGELPCH: u32 = 0, + ABOGJOHIGJL: u32 = 0, + + pub const _desc_table = .{ + .EPOPDGELPCH = fd(15, .{ .Varint = .Simple }), + .ABOGJOHIGJL = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEFOCGBFHOP = struct { + IMPBNMLGOPF: ArrayList(IOOGELPCMLN), + + pub const _desc_table = .{ + .IMPBNMLGOPF = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLCMHMNAPMA = struct { + LDMGIHBCHBL: ?BOFHBGBOFNE = null, + + pub const _desc_table = .{ + .LDMGIHBCHBL = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PAOGLFPDNOA = struct { + HANFDCIPMMD: ArrayList(u32), + ABHEGBEHLJK: ?KMLAOCOIBIL = null, + base_avatar_id_list: ArrayList(u32), + ABOLLMBDFJP: ArrayList(u32), + + pub const _desc_table = .{ + .HANFDCIPMMD = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .ABHEGBEHLJK = fd(3, .{ .SubMessage = {} }), + .base_avatar_id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .ABOLLMBDFJP = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DEBDGDLEBIE = struct { + FNLINMOJEME: ?CDGPDHMNMON = null, + + pub const _desc_table = .{ + .FNLINMOJEME = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEFDLNDMHBK = struct { + FAMLMPEPBLI: u32 = 0, + EGOHCFPCLPP: bool = false, + IGFKGOFCPAO: u32 = 0, + + pub const _desc_table = .{ + .FAMLMPEPBLI = fd(13, .{ .Varint = .Simple }), + .EGOHCFPCLPP = fd(3, .{ .Varint = .Simple }), + .IGFKGOFCPAO = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNGDOGDCNMI = struct { + CAONMAFIGLA: ArrayList(u32), + + pub const _desc_table = .{ + .CAONMAFIGLA = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GLICMBJEKHB = struct { + BIHOFLAIKAP: ArrayList(u32), + FAMLMPEPBLI: u32 = 0, + DKMDMKCMMPN: u32 = 0, + IGFKGOFCPAO: u32 = 0, + EGOHCFPCLPP: bool = false, + + pub const _desc_table = .{ + .BIHOFLAIKAP = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .FAMLMPEPBLI = fd(15, .{ .Varint = .Simple }), + .DKMDMKCMMPN = fd(11, .{ .Varint = .Simple }), + .IGFKGOFCPAO = fd(6, .{ .Varint = .Simple }), + .EGOHCFPCLPP = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKCOALBEGID = struct { + OOFAJAGAAOL: u32 = 0, + FDDOLEGBPHH: u32 = 0, + HMGLNINOCGH: u32 = 0, + + pub const _desc_table = .{ + .OOFAJAGAAOL = fd(4, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(2, .{ .Varint = .Simple }), + .HMGLNINOCGH = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLCIDMNIEFN = struct { + NICAMEMMIFD: ArrayList(CKCOALBEGID), + BABGDLHDFHE: u32 = 0, + KCILNHFLPFB: f32 = 0, + + pub const _desc_table = .{ + .NICAMEMMIFD = fd(13, .{ .List = .{ .SubMessage = {} } }), + .BABGDLHDFHE = fd(5, .{ .Varint = .Simple }), + .KCILNHFLPFB = fd(2, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCDAFCJDKMN = struct { + slot: u32 = 0, + id: u32 = 0, + level: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .slot = fd(14, .{ .Varint = .Simple }), + .id = fd(15, .{ .Varint = .Simple }), + .level = fd(13, .{ .Varint = .Simple }), + .avatar_type = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HACDNMIIION = struct { + buff_list: ArrayList(IOOGELPCMLN), + PKCPJMCBKPB: ArrayList(u32), + avatar_list: ArrayList(KCDAFCJDKMN), + + pub const _desc_table = .{ + .buff_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + .PKCPJMCBKPB = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_list = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJPBGKLIKOM = struct { + OJBOCHEBJFO: u32 = 0, + CDGDNPLKHDN: u32 = 0, + KAGHBIBAIPP: ?MLPPNJOPPML = null, + FJHJDMNBKDO: ?ItemList = null, + OCMOCECJGHJ: ?ItemList = null, + DNNHHDMJPHO: ?BMEEKBBCBFK = null, + ABOGJOHIGJL: u32 = 0, + BHEAOIOAGEC: ?HACDNMIIION = null, + MBCNKLPONEG: ?PLCIDMNIEFN = null, + MAGAIHIELEN: u32 = 0, + LEJJFNPJAOA: u32 = 0, + KFJLHEBDPNG: ?ItemList = null, + LDAMNJPGJOC: bool = false, + ONBDKKFHLAO: u32 = 0, + KKJNIACJBFK: bool = false, + NCBHLBJAAJK: ?BMEEKBBCBFK = null, + FDDOLEGBPHH: u32 = 0, + + pub const _desc_table = .{ + .OJBOCHEBJFO = fd(1, .{ .Varint = .Simple }), + .CDGDNPLKHDN = fd(1818, .{ .Varint = .Simple }), + .KAGHBIBAIPP = fd(13, .{ .SubMessage = {} }), + .FJHJDMNBKDO = fd(12, .{ .SubMessage = {} }), + .OCMOCECJGHJ = fd(9, .{ .SubMessage = {} }), + .DNNHHDMJPHO = fd(2, .{ .SubMessage = {} }), + .ABOGJOHIGJL = fd(7, .{ .Varint = .Simple }), + .BHEAOIOAGEC = fd(14, .{ .SubMessage = {} }), + .MBCNKLPONEG = fd(11, .{ .SubMessage = {} }), + .MAGAIHIELEN = fd(15, .{ .Varint = .Simple }), + .LEJJFNPJAOA = fd(8, .{ .Varint = .Simple }), + .KFJLHEBDPNG = fd(3, .{ .SubMessage = {} }), + .LDAMNJPGJOC = fd(4, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(1131, .{ .Varint = .Simple }), + .KKJNIACJBFK = fd(10, .{ .Varint = .Simple }), + .NCBHLBJAAJK = fd(5, .{ .SubMessage = {} }), + .FDDOLEGBPHH = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMEEKBBCBFK = struct { + KCHPOKNOMIA: u32 = 0, + OOKDLAINCCL: bool = false, + KOKNJDOFOEI: ArrayList(u32), + KBICEDMBLEG: u32 = 0, + LKFCOGDMNGJ: bool = false, + FEDDDLLKOLI: i64 = 0, + LGNPKHJFGFO: i64 = 0, + + pub const _desc_table = .{ + .KCHPOKNOMIA = fd(4, .{ .Varint = .Simple }), + .OOKDLAINCCL = fd(15, .{ .Varint = .Simple }), + .KOKNJDOFOEI = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .KBICEDMBLEG = fd(12, .{ .Varint = .Simple }), + .LKFCOGDMNGJ = fd(7, .{ .Varint = .Simple }), + .FEDDDLLKOLI = fd(1, .{ .Varint = .Simple }), + .LGNPKHJFGFO = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADFOPOJGBAK = struct { + FBNEHOBFJNP: u32 = 0, + IMMDGJFIAMC: u32 = 0, + exp: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .FBNEHOBFJNP = fd(11, .{ .Varint = .Simple }), + .IMMDGJFIAMC = fd(7, .{ .Varint = .Simple }), + .exp = fd(9, .{ .Varint = .Simple }), + .level = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RogueDialogueEventParam = struct { + int_value: i32 = 0, + arg_id: u32 = 0, + ratio: f32 = 0, + dialogue_event_id: u32 = 0, + is_valid: bool = false, + + pub const _desc_table = .{ + .int_value = fd(5, .{ .Varint = .Simple }), + .arg_id = fd(4, .{ .Varint = .Simple }), + .ratio = fd(9, .{ .FixedInt = .I32 }), + .dialogue_event_id = fd(7, .{ .Varint = .Simple }), + .is_valid = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MIJAFKCPBJP = struct { + KCDGGBHJOMF: u32 = 0, + PLADOEMBODM: u32 = 0, + MGAMAECMLBA: u32 = 0, + game_mode_type: u32 = 0, + HNICHMNGJBJ: ArrayList(RogueDialogueEventParam), + DCFFHJLMFEI: ArrayList(u32), + + pub const _desc_table = .{ + .KCDGGBHJOMF = fd(4, .{ .Varint = .Simple }), + .PLADOEMBODM = fd(3, .{ .Varint = .Simple }), + .MGAMAECMLBA = fd(14, .{ .Varint = .Simple }), + .game_mode_type = fd(10, .{ .Varint = .Simple }), + .HNICHMNGJBJ = fd(8, .{ .List = .{ .SubMessage = {} } }), + .DCFFHJLMFEI = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJEBLGIMPLF = struct { + AEOAMKLMBCB: IJMOGDNAAEB = @enumFromInt(0), + FHCCBCALCKE: ArrayList(u32), + IMOJCCEGMMM: ?ItemList = null, + + pub const _desc_table = .{ + .AEOAMKLMBCB = fd(11, .{ .Varint = .Simple }), + .FHCCBCALCKE = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .IMOJCCEGMMM = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POGOEGIFNGB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HJMNGNMJFBF = struct { + retcode: u32 = 0, + BHEIMEPJINE: ?GPDICDINPNF = null, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .BHEIMEPJINE = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBBNNOPJFJK = struct { + base_avatar_id_list: ArrayList(u32), + ONBDKKFHLAO: u32 = 0, + LDOLLOOEIKA: u32 = 0, + FACAIIIJEKI: ArrayList(u32), + HANFDCIPMMD: ArrayList(u32), + FBNEHOBFJNP: u32 = 0, + + pub const _desc_table = .{ + .base_avatar_id_list = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .ONBDKKFHLAO = fd(15, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(10, .{ .Varint = .Simple }), + .FACAIIIJEKI = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .HANFDCIPMMD = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .FBNEHOBFJNP = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOHPNOFKAMK = struct { + lineup: ?LineupInfo = null, + BHEIMEPJINE: ?GPDICDINPNF = null, + BENPBCFBKLF: ?ADFICOFDKCG = null, + scene: ?SceneInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .lineup = fd(7, .{ .SubMessage = {} }), + .BHEIMEPJINE = fd(12, .{ .SubMessage = {} }), + .BENPBCFBKLF = fd(15, .{ .SubMessage = {} }), + .scene = fd(2, .{ .SubMessage = {} }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PGHLGFDJLAF = struct { + ONBDKKFHLAO: u32 = 0, + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(13, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHKKIECPICB = struct { + retcode: u32 = 0, + lineup: ?LineupInfo = null, + BHEIMEPJINE: ?GPDICDINPNF = null, + BENPBCFBKLF: ?ADFICOFDKCG = null, + scene: ?SceneInfo = null, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .lineup = fd(1, .{ .SubMessage = {} }), + .BHEIMEPJINE = fd(6, .{ .SubMessage = {} }), + .BENPBCFBKLF = fd(13, .{ .SubMessage = {} }), + .scene = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPJAMCDFPIL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHIIIOMGOIF = struct { + BHEIMEPJINE: ?GPDICDINPNF = null, + retcode: u32 = 0, + BENPBCFBKLF: ?ADFICOFDKCG = null, + lineup: ?LineupInfo = null, + scene: ?SceneInfo = null, + + pub const _desc_table = .{ + .BHEIMEPJINE = fd(9, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + .BENPBCFBKLF = fd(7, .{ .SubMessage = {} }), + .lineup = fd(6, .{ .SubMessage = {} }), + .scene = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCBABGAIKND = struct { + IMIIPMGOHBP: ?KJPBGKLIKOM = null, + + pub const _desc_table = .{ + .IMIIPMGOHBP = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJPAFGMMHIE = struct { + base_avatar_id_list: ArrayList(u32), + prop_entity_id: u32 = 0, + HANFDCIPMMD: ArrayList(u32), + + pub const _desc_table = .{ + .base_avatar_id_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .prop_entity_id = fd(5, .{ .Varint = .Simple }), + .HANFDCIPMMD = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HECMOBPINIG = struct { + retcode: u32 = 0, + HANFDCIPMMD: ArrayList(u32), + base_avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .HANFDCIPMMD = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .base_avatar_id_list = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENGCHGMEHIH = struct { + base_avatar_id: u32 = 0, + HANFDCIPMMD: ArrayList(u32), + base_avatar_id_list: ArrayList(u32), + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .base_avatar_id = fd(1, .{ .Varint = .Simple }), + .HANFDCIPMMD = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .base_avatar_id_list = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .LDOLLOOEIKA = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNFBCJHAEGJ = struct { + ICKFEEIPHDK: u32 = 0, + ABHEGBEHLJK: ?KMLAOCOIBIL = null, + HANFDCIPMMD: ArrayList(u32), + base_avatar_id_list: ArrayList(u32), + retcode: u32 = 0, + base_avatar_id: u32 = 0, + + pub const _desc_table = .{ + .ICKFEEIPHDK = fd(6, .{ .Varint = .Simple }), + .ABHEGBEHLJK = fd(10, .{ .SubMessage = {} }), + .HANFDCIPMMD = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .base_avatar_id_list = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(8, .{ .Varint = .Simple }), + .base_avatar_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDKJFHDBJLD = struct { + ABHEGBEHLJK: ?KMLAOCOIBIL = null, + + pub const _desc_table = .{ + .ABHEGBEHLJK = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBMPPFBEOPG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOIGOPHPFNK = struct { + retcode: u32 = 0, + HKMIHNFPHAI: ?OLNGNLAOOIP = null, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .HKMIHNFPHAI = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HJPJJNMOJCK = struct { + IFDKIEDBFAE: u32 = 0, + + pub const _desc_table = .{ + .IFDKIEDBFAE = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GLCNLKJOMEF = struct { + retcode: u32 = 0, + PABMOLJDJBM: bool = false, + FAGHKLAOKDO: ?IOOGELPCMLN = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .PABMOLJDJBM = fd(3, .{ .Varint = .Simple }), + .FAGHKLAOKDO = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHIFBCKMPJC = struct { + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPJJHNENKHM = struct { + retcode: u32 = 0, + BHEIMEPJINE: ?GPDICDINPNF = null, + IMIIPMGOHBP: ?KJPBGKLIKOM = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .BHEIMEPJINE = fd(2, .{ .SubMessage = {} }), + .IMIIPMGOHBP = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFDGDICOBMB = struct { + GPOIMNADJOH: bool = false, + + pub const _desc_table = .{ + .GPOIMNADJOH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLAIAALBEKO = struct { + scene: ?SceneInfo = null, + GFLKOIMPFBF: bool = false, + lineup: ?LineupInfo = null, + EHLLPADLJPK: ?BMEEKBBCBFK = null, + IMIIPMGOHBP: ?KJPBGKLIKOM = null, + + pub const _desc_table = .{ + .scene = fd(13, .{ .SubMessage = {} }), + .GFLKOIMPFBF = fd(14, .{ .Varint = .Simple }), + .lineup = fd(11, .{ .SubMessage = {} }), + .EHLLPADLJPK = fd(6, .{ .SubMessage = {} }), + .IMIIPMGOHBP = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOICFFAAMND = struct { + LOPNFDJHCLN: u32 = 0, + HHNMDAKKDPD: u32 = 0, + + pub const _desc_table = .{ + .LOPNFDJHCLN = fd(1, .{ .Varint = .Simple }), + .HHNMDAKKDPD = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMDNMGHEKDK = struct { + EFHFKOOAGKG: u32 = 0, + lineup: ?LineupInfo = null, + scene: ?SceneInfo = null, + BENPBCFBKLF: ?ADFICOFDKCG = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EFHFKOOAGKG = fd(10, .{ .Varint = .Simple }), + .lineup = fd(15, .{ .SubMessage = {} }), + .scene = fd(13, .{ .SubMessage = {} }), + .BENPBCFBKLF = fd(9, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFPPIJMEOMB = struct { + EGKOJHEIOHH: u32 = 0, + GFEMNHLIEIB: ?DHMFJINEGJF = null, + + pub const _desc_table = .{ + .EGKOJHEIOHH = fd(6, .{ .Varint = .Simple }), + .GFEMNHLIEIB = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKEJANIOKJC = struct { + HLNFDPNENGO: bool = false, + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .HLNFDPNENGO = fd(8, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KNFHNKIOPCG = struct { + ENODKAHIHML: ?ItemList = null, + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .ENODKAHIHML = fd(7, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AELIFBJPCMB = struct { + count: u32 = 0, + + pub const _desc_table = .{ + .count = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ExchangeRogueRewardKeyScRsp = struct { + count: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .count = fd(14, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIIDDALFDHI = struct { + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCAHJFDCNDL = struct { + MLIJIGKLDCG: ?ItemList = null, + EFJKIDIANFG: ?ItemList = null, + + pub const _desc_table = .{ + .MLIJIGKLDCG = fd(11, .{ .SubMessage = {} }), + .EFJKIDIANFG = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDFBOPAFDAB = struct { + FBNEHOBFJNP: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .FBNEHOBFJNP = fd(7, .{ .Varint = .Simple }), + .level = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDGCLLMFHCM = struct { + retcode: u32 = 0, + FBNEHOBFJNP: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + level: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .FBNEHOBFJNP = fd(4, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(6, .{ .SubMessage = {} }), + .level = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFHDKCPDKOF = struct { + ADKJIIANOOM: ?ItemList = null, + level: u32 = 0, + FBNEHOBFJNP: u32 = 0, + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(1, .{ .SubMessage = {} }), + .level = fd(4, .{ .Varint = .Simple }), + .FBNEHOBFJNP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEALFDHNCNK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHGINGMIIDH = struct { + retcode: u32 = 0, + ILGGJOFHOCN: ?BMEEKBBCBFK = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .ILGGJOFHOCN = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHGADNKPFPO = struct { + KCHPOKNOMIA: u32 = 0, + ALPLIOJJAAH: ArrayList(u32), + + pub const _desc_table = .{ + .KCHPOKNOMIA = fd(4, .{ .Varint = .Simple }), + .ALPLIOJJAAH = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHJIIGJABNO = struct { + KCHPOKNOMIA: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + EHLLPADLJPK: ?BMEEKBBCBFK = null, + + pub const _desc_table = .{ + .KCHPOKNOMIA = fd(13, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(14, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + .EHLLPADLJPK = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IADHLHAFAAH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFJBIJGILIN = struct { + EHLLPADLJPK: ?BMEEKBBCBFK = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EHLLPADLJPK = fd(9, .{ .SubMessage = {} }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJFGLNIEAON = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AMIHNIAKANK = struct { + retcode: u32 = 0, + LOCNDHLENNO: ArrayList(ADFOPOJGBAK), + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .LOCNDHLENNO = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CCDAIEKMHDC = struct { + FBNEHOBFJNP: u32 = 0, + + pub const _desc_table = .{ + .FBNEHOBFJNP = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHJCCIFANOF = struct { + retcode: u32 = 0, + ODEHLKCFDIJ: ?ADFOPOJGBAK = null, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .ODEHLKCFDIJ = fd(10, .{ .SubMessage = {} }), + .ADKJIIANOOM = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPDPOGAJIHA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPBNGNCFMNH = struct { + retcode: u32 = 0, + GHCJGBFCGHH: ?EAHAIFANGDL = null, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .GHCJGBFCGHH = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OEJMAHOEDFD = struct { + KBJMNKPIBJH: u32 = 0, + + pub const _desc_table = .{ + .KBJMNKPIBJH = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONCJEAHEKCA = struct { + retcode: u32 = 0, + GHCJGBFCGHH: ?EAHAIFANGDL = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .GHCJGBFCGHH = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHMDNDLHPNM = struct { + GKHNCIGJIBE: ?NCAHJEHGCKP = null, + + pub const _desc_table = .{ + .GKHNCIGJIBE = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHHDJKLPIDH = struct { + IKGJCPMHHII: bool = false, + status: RogueStatus = @enumFromInt(0), + + pub const _desc_table = .{ + .IKGJCPMHHII = fd(9, .{ .Varint = .Simple }), + .status = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CDGLGKOCLLF = struct { + EHLLPADLJPK: ?BMEEKBBCBFK = null, + + pub const _desc_table = .{ + .EHLLPADLJPK = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOAFMKFLNGP = struct { + HANFDCIPMMD: ArrayList(u32), + base_avatar_id_list: ArrayList(u32), + + pub const _desc_table = .{ + .HANFDCIPMMD = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .base_avatar_id_list = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POJLIJLDEGC = struct { + BMDJPFNMPHN: ?GLICMBJEKHB = null, + + pub const _desc_table = .{ + .BMDJPFNMPHN = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JHALLHFNDEH = struct { + GIEPMIICFIC: u32 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .GIEPMIICFIC = fd(3, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBLNDEMIPMI = struct { + buff_list: ArrayList(JHALLHFNDEH), + + pub const _desc_table = .{ + .buff_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RogueCommonBuffSelectInfo = struct { + roll_buff_max_count: u32 = 0, + source_hint_id: u32 = 0, + source_total_count: u32 = 0, + can_roll: bool = false, + handbook_unlock_buff_id_list: ArrayList(u32), + roll_buff_free_count: u32 = 0, + roll_buff_cost_data: ?PEHCKCFABKB = null, + source_cur_count: u32 = 0, + certain_select_buff_id: u32 = 0, + select_buff_list: ArrayList(JHALLHFNDEH), + roll_buff_count: u32 = 0, + source_type: BMGHHGAHIIN = @enumFromInt(0), + first_buff_type_list: ArrayList(u32), + + pub const _desc_table = .{ + .roll_buff_max_count = fd(1, .{ .Varint = .Simple }), + .source_hint_id = fd(15, .{ .Varint = .Simple }), + .source_total_count = fd(3, .{ .Varint = .Simple }), + .can_roll = fd(7, .{ .Varint = .Simple }), + .handbook_unlock_buff_id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .roll_buff_free_count = fd(9, .{ .Varint = .Simple }), + .roll_buff_cost_data = fd(12, .{ .SubMessage = {} }), + .source_cur_count = fd(2, .{ .Varint = .Simple }), + .certain_select_buff_id = fd(14, .{ .Varint = .Simple }), + .select_buff_list = fd(10, .{ .List = .{ .SubMessage = {} } }), + .roll_buff_count = fd(6, .{ .Varint = .Simple }), + .source_type = fd(4, .{ .Varint = .Simple }), + .first_buff_type_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHCONLCJFOA = struct { + NBHMFBDILBN: u32 = 0, + + pub const _desc_table = .{ + .NBHMFBDILBN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADCHKANELBN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HMMMACGOHCA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCBKJHNEIDB = struct { + EAGBFNDJDED: ?RogueCommonBuffSelectInfo = null, + + pub const _desc_table = .{ + .EAGBFNDJDED = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELPJAPBHHCF = struct { + NOJPMGONLPN: u32 = 0, + HFBKPOBHBIM: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .NOJPMGONLPN = fd(8, .{ .Varint = .Simple }), + .HFBKPOBHBIM = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBGPFIPBDLB = struct { + BJNNANHPCNG: ArrayList(ELPJAPBHHCF), + + pub const _desc_table = .{ + .BJNNANHPCNG = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMCOCHNGMPN = struct { + PIIINAKMKCA: ArrayList(JHALLHFNDEH), + DCECFOKFIHH: u32 = 0, + HFIBNMPNCFG: ArrayList(JHALLHFNDEH), + + pub const _desc_table = .{ + .PIIINAKMKCA = fd(3, .{ .List = .{ .SubMessage = {} } }), + .DCECFOKFIHH = fd(7, .{ .Varint = .Simple }), + .HFIBNMPNCFG = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFPIHKDCMME = struct { + PIIINAKMKCA: ArrayList(JHALLHFNDEH), + DCECFOKFIHH: u32 = 0, + + pub const _desc_table = .{ + .PIIINAKMKCA = fd(5, .{ .List = .{ .SubMessage = {} } }), + .DCECFOKFIHH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCGNPINDCJO = struct { + OOJKHHJNEFL: u32 = 0, + + pub const _desc_table = .{ + .OOJKHHJNEFL = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APMPMCHABII = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECBKGCFNANB = struct { + DBNJGEEONOK: ArrayList(JHALLHFNDEH), + DCECFOKFIHH: u32 = 0, + + pub const _desc_table = .{ + .DBNJGEEONOK = fd(10, .{ .List = .{ .SubMessage = {} } }), + .DCECFOKFIHH = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKHCONJBMHD = struct { + NBHMFBDILBN: u32 = 0, + + pub const _desc_table = .{ + .NBHMFBDILBN = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GFHOEAAAOCO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECMOGCMOJJH = struct { + DCECFOKFIHH: u32 = 0, + MNIDHBDDGIO: ArrayList(JHALLHFNDEH), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(3, .{ .Varint = .Simple }), + .MNIDHBDDGIO = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEKMDCIMHHG = struct { + NBHMFBDILBN: u32 = 0, + + pub const _desc_table = .{ + .NBHMFBDILBN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OONPKDFMPDA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKHJMMFFDFD = struct { + CAIHLMOIFHG: ?BBLNDEMIPMI = null, + + pub const _desc_table = .{ + .CAIHLMOIFHG = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDBKEEFGCGF = struct { + KABNOGFDKFI: u32 = 0, + NDPAMBJKKFD: u32 = 0, + NFNNOMAMNAA: u32 = 0, + JBFJGEIGGBA: ArrayList(JBFJGEIGGBAEntry), + + pub const _desc_table = .{ + .KABNOGFDKFI = fd(15, .{ .Varint = .Simple }), + .NDPAMBJKKFD = fd(8, .{ .Varint = .Simple }), + .NFNNOMAMNAA = fd(9, .{ .Varint = .Simple }), + .JBFJGEIGGBA = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const JBFJGEIGGBAEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIEIEMGILHP = struct { + NJCECKPBJDF: ?KDBKEEFGCGF = null, + CKDEBMAKNMC: bool = false, + KOKHPCCGEMG: u32 = 0, + + pub const _desc_table = .{ + .NJCECKPBJDF = fd(2, .{ .SubMessage = {} }), + .CKDEBMAKNMC = fd(13, .{ .Varint = .Simple }), + .KOKHPCCGEMG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDOCHDCIFOL = struct { + PFKIOEPNOII: ?KDBKEEFGCGF = null, + + pub const _desc_table = .{ + .PFKIOEPNOII = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHLDCELKDKB = struct { + NDPAMBJKKFD: u32 = 0, + + pub const _desc_table = .{ + .NDPAMBJKKFD = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFKGDNPFJAA = struct { + ADGLKIGHPOA: u32 = 0, + PFKIOEPNOII: ?KDBKEEFGCGF = null, + + pub const _desc_table = .{ + .ADGLKIGHPOA = fd(15, .{ .Varint = .Simple }), + .PFKIOEPNOII = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGOIJBNMIEP = struct { + PFKIOEPNOII: ?KDBKEEFGCGF = null, + + pub const _desc_table = .{ + .PFKIOEPNOII = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBIOOAHFDEM = struct { + KOKHPCCGEMG: u32 = 0, + NJCECKPBJDF: ?KDBKEEFGCGF = null, + + pub const _desc_table = .{ + .KOKHPCCGEMG = fd(2, .{ .Varint = .Simple }), + .NJCECKPBJDF = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPPPBHGHJDF = struct { + PFKIOEPNOII: ?KDBKEEFGCGF = null, + + pub const _desc_table = .{ + .PFKIOEPNOII = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJBBJBIHOCP = struct { + PKCPJMCBKPB: ArrayList(KDBKEEFGCGF), + + pub const _desc_table = .{ + .PKCPJMCBKPB = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEBFMIKBIEA = struct { + MIEDMKJNAHO: ArrayList(u32), + DCECFOKFIHH: u32 = 0, + NMGLMKJGANP: ArrayList(u32), + + pub const _desc_table = .{ + .MIEDMKJNAHO = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .DCECFOKFIHH = fd(10, .{ .Varint = .Simple }), + .NMGLMKJGANP = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMPEBFGKEEE = struct { + MDFHIJKNCBP: u32 = 0, + + pub const _desc_table = .{ + .MDFHIJKNCBP = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OEABNDMNIDN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCHBHHHFBPM = struct { + GHJIDOPJDOM: ArrayList(u32), + + pub const _desc_table = .{ + .GHJIDOPJDOM = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDALALGLJJC = struct { + DCECFOKFIHH: u32 = 0, + NPAEJCNNIEN: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(1, .{ .Varint = .Simple }), + .NPAEJCNNIEN = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JILKCLLHDHL = struct { + LDCNDJDFJCE: u32 = 0, + + pub const _desc_table = .{ + .LDCNDJDFJCE = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBEBACENHBE = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EPECOIGOEAF = struct { + DCECFOKFIHH: u32 = 0, + ICELECFCEJN: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(6, .{ .Varint = .Simple }), + .ICELECFCEJN = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBKOOIIODFC = struct { + IEHABJGGJCE: u32 = 0, + + pub const _desc_table = .{ + .IEHABJGGJCE = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEBMBCJECBJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJFDHIAPLAI = struct { + DCECFOKFIHH: u32 = 0, + GEHJLOHEGGB: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(3, .{ .Varint = .Simple }), + .GEHJLOHEGGB = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJMEIIHOINJ = struct { + BPEIGMNBJJJ: u32 = 0, + + pub const _desc_table = .{ + .BPEIGMNBJJJ = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOGKAPNKCOI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AIAFLIFPJFP = struct { + DCECFOKFIHH: u32 = 0, + DAAEAJFCNKN: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(12, .{ .Varint = .Simple }), + .DAAEAJFCNKN = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DKDLBLJHAMB = struct { + IMPPDMCGEFN: u32 = 0, + + pub const _desc_table = .{ + .IMPPDMCGEFN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMKMMFJEMDL = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IEKOLCJKMML = struct { + DCECFOKFIHH: u32 = 0, + IPAPJCOAIFG: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(2, .{ .Varint = .Simple }), + .IPAPJCOAIFG = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLFOBIBCPEO = struct { + MDFHIJKNCBP: u32 = 0, + + pub const _desc_table = .{ + .MDFHIJKNCBP = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEAODLAHIDP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NILLPIGHKGK = struct { + DCECFOKFIHH: u32 = 0, + IPAPJCOAIFG: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(3, .{ .Varint = .Simple }), + .IPAPJCOAIFG = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADMOCCBHGIE = struct { + MDFHIJKNCBP: u32 = 0, + + pub const _desc_table = .{ + .MDFHIJKNCBP = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIHAGDAFBFI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HIGNCEDLMFL = struct { + IMJDBJIAOOI: u32 = 0, + + pub const _desc_table = .{ + .IMJDBJIAOOI = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFFBBAFGKIG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGPKGFPBGMK = struct { + APJCIBOMJJC: ?FJBBJBIHOCP = null, + + pub const _desc_table = .{ + .APJCIBOMJJC = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGGGMJGMNNM = struct { + GHKHNNNELME: ArrayList(u32), + + pub const _desc_table = .{ + .GHKHNNNELME = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IBLHIDENCOG = struct { + CKOJDJGLADK: u32 = 0, + DBHNODMDBBG: u32 = 0, + CFMBNFAAJCG: u32 = 0, + DIHCFKEFJKL: u32 = 0, + + pub const _desc_table = .{ + .CKOJDJGLADK = fd(12, .{ .Varint = .Simple }), + .DBHNODMDBBG = fd(7, .{ .Varint = .Simple }), + .CFMBNFAAJCG = fd(5, .{ .Varint = .Simple }), + .DIHCFKEFJKL = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBKDOJFLDGB = struct { + NHFGFOCFGCG: u32 = 0, + GJNPNGDMGMH: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(14, .{ .Varint = .Simple }), + .GJNPNGDMGMH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOMCCJGJHNM = struct { + avatar_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(5, .{ .Varint = .Simple }), + .avatar_type = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RogueSyncContextBoardEvent = struct { + modifier_effect_type: u32 = 0, + board_event_id: u32 = 0, + + pub const _desc_table = .{ + .modifier_effect_type = fd(3, .{ .Varint = .Simple }), + .board_event_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGBBFBLLJLG = struct { + LHFFLOKIELE: ?ItemList = null, + + pub const _desc_table = .{ + .LHFFLOKIELE = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FOKHJCJLCLO = struct { + BACGPMJGLMK: ?HGBBFBLLJLG = null, + LJBKOGGALID: ?RogueSyncContextBoardEvent = null, + + pub const _desc_table = .{ + .BACGPMJGLMK = fd(1, .{ .SubMessage = {} }), + .LJBKOGGALID = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BLAPNMNBFNH = struct { + DDMDMOMBNJH: u32 = 0, + FJMFONCKJCB: u32 = 0, + status: u32 = 0, + FDDOLEGBPHH: u32 = 0, + AGLDIPPONDM: f64 = 0, + + pub const _desc_table = .{ + .DDMDMOMBNJH = fd(15, .{ .Varint = .Simple }), + .FJMFONCKJCB = fd(11, .{ .Varint = .Simple }), + .status = fd(1, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(13, .{ .Varint = .Simple }), + .AGLDIPPONDM = fd(9, .{ .FixedInt = .I64 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCNICPMFMNJ = struct { + MEBPECJHKNF: ?BLAPNMNBFNH = null, + + pub const _desc_table = .{ + .MEBPECJHKNF = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIPNNNBOEHO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGNJBJNPMIE = struct { + MEBPECJHKNF: ?BLAPNMNBFNH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MEBPECJHKNF = fd(7, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CELJODKGONA = struct { + HMACEGNJGDN: u32 = 0, + + pub const _desc_table = .{ + .HMACEGNJGDN = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PACGFNKEFPC = struct { + MEBPECJHKNF: ?BLAPNMNBFNH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MEBPECJHKNF = fd(15, .{ .SubMessage = {} }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EIAOHJAKGFC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LINJOFDDDCO = struct { + retcode: u32 = 0, + MEBPECJHKNF: ?BLAPNMNBFNH = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .MEBPECJHKNF = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJHFKEEGGOK = struct { + FDDOLEGBPHH: u32 = 0, + EECDAKBHKMK: u32 = 0, + + pub const _desc_table = .{ + .FDDOLEGBPHH = fd(6, .{ .Varint = .Simple }), + .EECDAKBHKMK = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HICBPIABJPF = struct { + MEBPECJHKNF: ?BLAPNMNBFNH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MEBPECJHKNF = fd(7, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCLFFMLHBJO = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + NDPAMBJKKFD: u32 = 0, + BCLEGGBLDIL: bool = false, + MMLFGHDAMLE: ?PEHCKCFABKB = null, + MMKACGNCMEK: bool = false, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(12, .{ .SubMessage = {} }), + .NDPAMBJKKFD = fd(6, .{ .Varint = .Simple }), + .BCLEGGBLDIL = fd(13, .{ .Varint = .Simple }), + .MMLFGHDAMLE = fd(1, .{ .SubMessage = {} }), + .MMKACGNCMEK = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GAENPLOMKJK = struct { + MMLFGHDAMLE: ?PEHCKCFABKB = null, + NOJPMGONLPN: u32 = 0, + HFBKPOBHBIM: ?PEHCKCFABKB = null, + MMKACGNCMEK: bool = false, + BCLEGGBLDIL: bool = false, + BLHKNGMAPIO: u32 = 0, + + pub const _desc_table = .{ + .MMLFGHDAMLE = fd(10, .{ .SubMessage = {} }), + .NOJPMGONLPN = fd(15, .{ .Varint = .Simple }), + .HFBKPOBHBIM = fd(4, .{ .SubMessage = {} }), + .MMKACGNCMEK = fd(13, .{ .Varint = .Simple }), + .BCLEGGBLDIL = fd(3, .{ .Varint = .Simple }), + .BLHKNGMAPIO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHEPGANHMNJ = struct { + PKCPJMCBKPB: ArrayList(BCLFFMLHBJO), + + pub const _desc_table = .{ + .PKCPJMCBKPB = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLIFEGFBPIJ = struct { + buff_list: ArrayList(GAENPLOMKJK), + + pub const _desc_table = .{ + .buff_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMKFKBEFMLC = struct { + LDOLLOOEIKA: u32 = 0, + CDBIHIBLMLI: bool = false, + + pub const _desc_table = .{ + .LDOLLOOEIKA = fd(6, .{ .Varint = .Simple }), + .CDBIHIBLMLI = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPCIOMHABEM = struct { + EHCBNGINOGC: bool = false, + DNNNDJCADJE: ?CLIFEGFBPIJ = null, + retcode: u32 = 0, + PPNILJNPPAG: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .EHCBNGINOGC = fd(13, .{ .Varint = .Simple }), + .DNNNDJCADJE = fd(5, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + .PPNILJNPPAG = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLDCHEHKANI = struct { + CDBIHIBLMLI: bool = false, + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .CDBIHIBLMLI = fd(1, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBNCIJHDCFM = struct { + PPNILJNPPAG: ?PEHCKCFABKB = null, + LDMGIHBCHBL: ?IHEPGANHMNJ = null, + EHCBNGINOGC: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .PPNILJNPPAG = fd(11, .{ .SubMessage = {} }), + .LDMGIHBCHBL = fd(8, .{ .SubMessage = {} }), + .EHCBNGINOGC = fd(5, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMOIDAJEMOO = struct { + NDPAMBJKKFD: u32 = 0, + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .NDPAMBJKKFD = fd(7, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NDLDDAMOGPH = struct { + buff_id_list: ArrayList(u32), + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .buff_id_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .LDOLLOOEIKA = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBKAGOEDHLN = struct { + LDMGIHBCHBL: ?IHEPGANHMNJ = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .LDMGIHBCHBL = fd(10, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMFHLJHFNLK = struct { + retcode: u32 = 0, + DNNNDJCADJE: ?CLIFEGFBPIJ = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .DNNNDJCADJE = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJNCKFCLKAO = struct { + LDOLLOOEIKA: u32 = 0, + NDPAMBJKKFD: u32 = 0, + + pub const _desc_table = .{ + .LDOLLOOEIKA = fd(13, .{ .Varint = .Simple }), + .NDPAMBJKKFD = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JFPFFIKAJBH = struct { + NCIGBGIDJPE: ?JHALLHFNDEH = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .NCIGBGIDJPE = fd(8, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GOFAGIKKHPE = struct { + PECAOEBJIBL: u32 = 0, + + pub const _desc_table = .{ + .PECAOEBJIBL = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPJFOFKHEED = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NHLAMHCPMKH = struct { + IFDKIEDBFAE: u32 = 0, + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .IFDKIEDBFAE = fd(13, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMJAGNMJMPI = struct { + retcode: u32 = 0, + FAGHKLAOKDO: ?JHALLHFNDEH = null, + PABMOLJDJBM: bool = false, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .FAGHKLAOKDO = fd(3, .{ .SubMessage = {} }), + .PABMOLJDJBM = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODECJBKOCLB = struct { + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .LDOLLOOEIKA = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetEnhanceCommonRogueBuffInfoScRsp = struct { + enhanced_buff_id_list: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .enhanced_buff_id_list = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BANNKMICEAA = struct { + GJNPNGDMGMH: OEDKCPFBCAP = @enumFromInt(0), + FDGHFKBNDKC: ArrayList(ELCMBGEAOMN), + NNLELKHHBCL: u32 = 0, + + pub const _desc_table = .{ + .GJNPNGDMGMH = fd(8, .{ .Varint = .Simple }), + .FDGHFKBNDKC = fd(5, .{ .List = .{ .SubMessage = {} } }), + .NNLELKHHBCL = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELCMBGEAOMN = struct { + EOLEGGEPOIO: ?OHNBILFPCDM = null, + LGEKDBJJLNI: KHKFCCLABMD = @enumFromInt(0), + + pub const _desc_table = .{ + .EOLEGGEPOIO = fd(4, .{ .SubMessage = {} }), + .LGEKDBJJLNI = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMIAIMDBIAI = struct { + MBBNDDLBEPE: u32 = 0, + NFBKGNACLNH: i32 = 0, + + pub const _desc_table = .{ + .MBBNDDLBEPE = fd(9, .{ .Varint = .Simple }), + .NFBKGNACLNH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICKCNJHEOHF = struct { + GCBLDBNEIDB: u32 = 0, + AEODAIHGNMG: bool = false, + OEHIOMMJENL: ArrayList(FMIAIMDBIAI), + + pub const _desc_table = .{ + .GCBLDBNEIDB = fd(1, .{ .Varint = .Simple }), + .AEODAIHGNMG = fd(15, .{ .Varint = .Simple }), + .OEHIOMMJENL = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGGMCDAJJDL = struct { + IIPBCIFMNJF: ArrayList(IIPBCIFMNJFEntry), + + pub const _desc_table = .{ + .IIPBCIFMNJF = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const IIPBCIFMNJFEntry = struct { + key: u32 = 0, + value: i32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJILLCDOCDL = struct { + DDGMJGBNJJP: ?ICKCNJHEOHF = null, + + pub const _desc_table = .{ + .DDGMJGBNJJP = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BANENCLAHFH = struct { + DDGMJGBNJJP: ?ICKCNJHEOHF = null, + + pub const _desc_table = .{ + .DDGMJGBNJJP = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCEGOHOHIGK = struct { + DDGMJGBNJJP: ?ICKCNJHEOHF = null, + + pub const _desc_table = .{ + .DDGMJGBNJJP = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCKINKMKFOJ = struct { + DDGMJGBNJJP: ?ICKCNJHEOHF = null, + + pub const _desc_table = .{ + .DDGMJGBNJJP = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEPPCFCOCMC = struct { + value: ?LGGMCDAJJDL = null, + + pub const _desc_table = .{ + .value = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECPKADOCDID = struct { + OGKBHBCOBHN: ?LGGMCDAJJDL = null, + HLDEEINACIP: ArrayList(ICKCNJHEOHF), + + pub const _desc_table = .{ + .OGKBHBCOBHN = fd(9, .{ .SubMessage = {} }), + .HLDEEINACIP = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJCHGNPKPKB = struct { + HHEONKFINAI: u32 = 0, + + pub const _desc_table = .{ + .HHEONKFINAI = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCCENMIJJDG = struct { + HHEONKFINAI: u32 = 0, + + pub const _desc_table = .{ + .HHEONKFINAI = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDPJIKHEAJE = struct { + LIOMMCDDCGN: ArrayList(LIOMMCDDCGNEntry), + + pub const _desc_table = .{ + .LIOMMCDDCGN = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const LIOMMCDDCGNEntry = struct { + key: u32 = 0, + value: bool = false, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHNBILFPCDM = struct { + EAIFLKDLGKB: ?HBKDOJFLDGB = null, + NHIIBCDECGF: ?HBKDOJFLDGB = null, + FIFIACFLFDL: ?JHALLHFNDEH = null, + AGMHGBGGGFN: ?JHALLHFNDEH = null, + LDLHLAAMLHD: ?MDOCHDCIFOL = null, + KDGKHHFHFBJ: ?EHLDCELKDKB = null, + DHHFCKKDFNJ: ?AFKGDNPFJAA = null, + ONGBGHBJBBF: ?FGOIJBNMIEP = null, + EKMBBHEHEPC: ?FBIOOAHFDEM = null, + HEIJFDDMMFJ: ?LPPPBHGHJDF = null, + MICOCBNMEAJ: ?KOMCCJGJHNM = null, + NDAJBDONKLK: ?JJILLCDOCDL = null, + NKMIJHMBCJE: ?BANENCLAHFH = null, + GACMJKONLPO: ?JCEGOHOHIGK = null, + KDHCEKHEIEK: ?FCKINKMKFOJ = null, + OCFHDHJHOLH: ?MEPPCFCOCMC = null, + KFMONGPPLIE: ?LJCHGNPKPKB = null, + JBPJOAHOBGM: ?DCCENMIJJDG = null, + + pub const _desc_table = .{ + .EAIFLKDLGKB = fd(6, .{ .SubMessage = {} }), + .NHIIBCDECGF = fd(2, .{ .SubMessage = {} }), + .FIFIACFLFDL = fd(1884, .{ .SubMessage = {} }), + .AGMHGBGGGFN = fd(1544, .{ .SubMessage = {} }), + .LDLHLAAMLHD = fd(1263, .{ .SubMessage = {} }), + .KDGKHHFHFBJ = fd(1017, .{ .SubMessage = {} }), + .DHHFCKKDFNJ = fd(861, .{ .SubMessage = {} }), + .ONGBGHBJBBF = fd(217, .{ .SubMessage = {} }), + .EKMBBHEHEPC = fd(1386, .{ .SubMessage = {} }), + .HEIJFDDMMFJ = fd(265, .{ .SubMessage = {} }), + .MICOCBNMEAJ = fd(330, .{ .SubMessage = {} }), + .NDAJBDONKLK = fd(776, .{ .SubMessage = {} }), + .NKMIJHMBCJE = fd(2044, .{ .SubMessage = {} }), + .GACMJKONLPO = fd(1519, .{ .SubMessage = {} }), + .KDHCEKHEIEK = fd(1280, .{ .SubMessage = {} }), + .OCFHDHJHOLH = fd(1843, .{ .SubMessage = {} }), + .KFMONGPPLIE = fd(1434, .{ .SubMessage = {} }), + .JBPJOAHOBGM = fd(1346, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RogueFormulaSelectInfo = struct { + hint_id: u32 = 0, + select_formula_id_list: ArrayList(u32), + handbook_unlock_formula_id_list: ArrayList(u32), + roll_formula_cost_data: ?PEHCKCFABKB = null, + roll_formula_count: u32 = 0, + can_roll: bool = false, + roll_formula_free_count: u32 = 0, + roll_formula_max_count: u32 = 0, + + pub const _desc_table = .{ + .hint_id = fd(11, .{ .Varint = .Simple }), + .select_formula_id_list = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .handbook_unlock_formula_id_list = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .roll_formula_cost_data = fd(9, .{ .SubMessage = {} }), + .roll_formula_count = fd(6, .{ .Varint = .Simple }), + .can_roll = fd(15, .{ .Varint = .Simple }), + .roll_formula_free_count = fd(4, .{ .Varint = .Simple }), + .roll_formula_max_count = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPEFAMNMFDG = struct { + IMEDENKBCKJ: u32 = 0, + + pub const _desc_table = .{ + .IMEDENKBCKJ = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLBMDCAJIGF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OABIBGMGIIE = struct { + DCECFOKFIHH: u32 = 0, + ACDOBNPFPAP: ArrayList(u32), + + pub const _desc_table = .{ + .DCECFOKFIHH = fd(10, .{ .Varint = .Simple }), + .ACDOBNPFPAP = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOAHHEAOFFK = struct { + IMEDENKBCKJ: u32 = 0, + + pub const _desc_table = .{ + .IMEDENKBCKJ = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKALMAIDIGF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DELGOOPEKOM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILBOACGHEGD = struct { + AGBDJLNDJEL: ?RogueFormulaSelectInfo = null, + + pub const _desc_table = .{ + .AGBDJLNDJEL = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CHKJICPBHPA = struct { + AGBDJLNDJEL: ?RogueFormulaSelectInfo = null, + + pub const _desc_table = .{ + .AGBDJLNDJEL = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHOPHFCMOKH = struct { + IMEDENKBCKJ: u32 = 0, + + pub const _desc_table = .{ + .IMEDENKBCKJ = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDNIMPBHDHB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IIJJHNNNKCF = struct { + LDAMNJPGJOC: bool = false, + DGGCAFCLPFB: u32 = 0, + + pub const _desc_table = .{ + .LDAMNJPGJOC = fd(15, .{ .Varint = .Simple }), + .DGGCAFCLPFB = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIMBLEPCEPD = struct { + DFOLOHBFFJJ: ?IMIKGILFCCI = null, + NNLELKHHBCL: u32 = 0, + + pub const _desc_table = .{ + .DFOLOHBFFJJ = fd(7, .{ .SubMessage = {} }), + .NNLELKHHBCL = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IMIKGILFCCI = struct { + EOLEGGEPOIO: ?FELKOBECFBP = null, + KDDFCIJKDKK: u32 = 0, + + pub const _desc_table = .{ + .EOLEGGEPOIO = fd(12, .{ .SubMessage = {} }), + .KDDFCIJKDKK = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FELKOBECFBP = struct { + EAGBFNDJDED: ?RogueCommonBuffSelectInfo = null, + HBHFHCNKIBA: ?EFPIHKDCMME = null, + JKEJALPLIBP: ?ECBKGCFNANB = null, + FBIBBHIBHAA: ?ECMOGCMOJJH = null, + JLLKPODDJNK: ?CEBFMIKBIEA = null, + GLLOCFABBPD: ?NCHBHHHFBPM = null, + GNOCICNIFJH: ?MDALALGLJJC = null, + DBOFJOJCDKK: ?EPECOIGOEAF = null, + MEMAHJEECMD: ?LJFDHIAPLAI = null, + PIKAJBPNFPF: ?AIAFLIFPJFP = null, + FKCGFGKLIID: ?IEKOLCJKMML = null, + GBDDILHDOEN: ?NILLPIGHKGK = null, + FNLINMOJEME: ?JGGGMJGMNNM = null, + AGBDJLNDJEL: ?RogueFormulaSelectInfo = null, + LMGIMCMGGJL: ?OABIBGMGIIE = null, + KIMHACECBKF: ?CHKJICPBHPA = null, + + pub const _desc_table = .{ + .EAGBFNDJDED = fd(820, .{ .SubMessage = {} }), + .HBHFHCNKIBA = fd(1471, .{ .SubMessage = {} }), + .JKEJALPLIBP = fd(638, .{ .SubMessage = {} }), + .FBIBBHIBHAA = fd(1102, .{ .SubMessage = {} }), + .JLLKPODDJNK = fd(1995, .{ .SubMessage = {} }), + .GLLOCFABBPD = fd(240, .{ .SubMessage = {} }), + .GNOCICNIFJH = fd(1263, .{ .SubMessage = {} }), + .DBOFJOJCDKK = fd(674, .{ .SubMessage = {} }), + .MEMAHJEECMD = fd(1971, .{ .SubMessage = {} }), + .PIKAJBPNFPF = fd(133, .{ .SubMessage = {} }), + .FKCGFGKLIID = fd(144, .{ .SubMessage = {} }), + .GBDDILHDOEN = fd(451, .{ .SubMessage = {} }), + .FNLINMOJEME = fd(1849, .{ .SubMessage = {} }), + .AGBDJLNDJEL = fd(113, .{ .SubMessage = {} }), + .LMGIMCMGGJL = fd(305, .{ .SubMessage = {} }), + .KIMHACECBKF = fd(207, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BIJCPIDFJMH = struct { + BOANDNKLJBI: u32 = 0, + GAMJAOBEMDO: ?GHCONLCJFOA = null, + CLOMAFJKKOP: ?FCGNPINDCJO = null, + EBFFLNAPJHJ: ?KKHCONJBMHD = null, + CPNAPDIKOOK: ?HMMMACGOHCA = null, + NLHEFFPICMN: ?BEKMDCIMHHG = null, + NMEJDKCOEOE: ?NMPEBFGKEEE = null, + GDLGGEDGJKN: ?JILKCLLHDHL = null, + FKOJLMBOKGJ: ?GBKOOIIODFC = null, + MLDGGJIBFCO: ?BJMEIIHOINJ = null, + LDKODDLEAKP: ?DKDLBLJHAMB = null, + JLMOPLPFPOP: ?NLFOBIBCPEO = null, + KPAHINHGNJI: ?ADMOCCBHGIE = null, + FKGBJOKIEPI: ?HIGNCEDLMFL = null, + OEBODAOKLPE: ?KPEFAMNMFDG = null, + GLLFBCGDMJA: ?DELGOOPEKOM = null, + KEPJDAKKDOJ: ?EOAHHEAOFFK = null, + IOJKNOLKFLD: ?OHOPHFCMOKH = null, + NANBLBHDPPG: ?IIJJHNNNKCF = null, + + pub const _desc_table = .{ + .BOANDNKLJBI = fd(6, .{ .Varint = .Simple }), + .GAMJAOBEMDO = fd(309, .{ .SubMessage = {} }), + .CLOMAFJKKOP = fd(806, .{ .SubMessage = {} }), + .EBFFLNAPJHJ = fd(1291, .{ .SubMessage = {} }), + .CPNAPDIKOOK = fd(1008, .{ .SubMessage = {} }), + .NLHEFFPICMN = fd(1974, .{ .SubMessage = {} }), + .NMEJDKCOEOE = fd(1833, .{ .SubMessage = {} }), + .GDLGGEDGJKN = fd(165, .{ .SubMessage = {} }), + .FKOJLMBOKGJ = fd(1639, .{ .SubMessage = {} }), + .MLDGGJIBFCO = fd(1902, .{ .SubMessage = {} }), + .LDKODDLEAKP = fd(1740, .{ .SubMessage = {} }), + .JLMOPLPFPOP = fd(356, .{ .SubMessage = {} }), + .KPAHINHGNJI = fd(814, .{ .SubMessage = {} }), + .FKGBJOKIEPI = fd(897, .{ .SubMessage = {} }), + .OEBODAOKLPE = fd(1752, .{ .SubMessage = {} }), + .GLLFBCGDMJA = fd(1134, .{ .SubMessage = {} }), + .KEPJDAKKDOJ = fd(1441, .{ .SubMessage = {} }), + .IOJKNOLKFLD = fd(1006, .{ .SubMessage = {} }), + .NANBLBHDPPG = fd(10380, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EJHEPALECHN = struct { + KDDFCIJKDKK: u32 = 0, + BOANDNKLJBI: u32 = 0, + retcode: u32 = 0, + JGHFCLPBADA: ?ADCHKANELBN = null, + BFEOAJMCIMI: ?APMPMCHABII = null, + PNIHMAAPMIG: ?GFHOEAAAOCO = null, + DGHJDHIJHCC: ?NCBKJHNEIDB = null, + BCLAIIEKMEK: ?OONPKDFMPDA = null, + DGHOFLBPLOM: ?OEABNDMNIDN = null, + KOIPMHGJJBI: ?HBEBACENHBE = null, + GIKHFCFCKMO: ?MEBMBCJECBJ = null, + EPKDBDGBHIC: ?JOGKAPNKCOI = null, + CEHNAAOODDG: ?MMKMMFJEMDL = null, + IHPHBLCLKEI: ?MEAODLAHIDP = null, + DIBJKEBNIPK: ?CIHAGDAFBFI = null, + PKNLIDADHAC: ?LFFBBAFGKIG = null, + IMGEOFNPBDP: ?FLBMDCAJIGF = null, + ONLMPLCMLOG: ?ILBOACGHEGD = null, + KBDCMLFNEOL: ?KKALMAIDIGF = null, + PMOKDHEFMCD: ?EDNIMPBHDHB = null, + + pub const _desc_table = .{ + .KDDFCIJKDKK = fd(5, .{ .Varint = .Simple }), + .BOANDNKLJBI = fd(7, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .JGHFCLPBADA = fd(1689, .{ .SubMessage = {} }), + .BFEOAJMCIMI = fd(1077, .{ .SubMessage = {} }), + .PNIHMAAPMIG = fd(157, .{ .SubMessage = {} }), + .DGHJDHIJHCC = fd(952, .{ .SubMessage = {} }), + .BCLAIIEKMEK = fd(34, .{ .SubMessage = {} }), + .DGHOFLBPLOM = fd(689, .{ .SubMessage = {} }), + .KOIPMHGJJBI = fd(290, .{ .SubMessage = {} }), + .GIKHFCFCKMO = fd(848, .{ .SubMessage = {} }), + .EPKDBDGBHIC = fd(1241, .{ .SubMessage = {} }), + .CEHNAAOODDG = fd(253, .{ .SubMessage = {} }), + .IHPHBLCLKEI = fd(295, .{ .SubMessage = {} }), + .DIBJKEBNIPK = fd(738, .{ .SubMessage = {} }), + .PKNLIDADHAC = fd(176, .{ .SubMessage = {} }), + .IMGEOFNPBDP = fd(801, .{ .SubMessage = {} }), + .ONLMPLCMLOG = fd(493, .{ .SubMessage = {} }), + .KBDCMLFNEOL = fd(1083, .{ .SubMessage = {} }), + .PMOKDHEFMCD = fd(246, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABGIMIMBJHI = struct { + IFDKIEDBFAE: u32 = 0, + + pub const _desc_table = .{ + .IFDKIEDBFAE = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CABEFCJFAGI = struct { + BCHNGDIFJGN: u32 = 0, + IDHCLDDENHB: bool = false, + + pub const _desc_table = .{ + .BCHNGDIFJGN = fd(5, .{ .Varint = .Simple }), + .IDHCLDDENHB = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKKLLNLEPDF = struct { + OKBDNIKNJHC: u32 = 0, + IDHCLDDENHB: bool = false, + + pub const _desc_table = .{ + .OKBDNIKNJHC = fd(10, .{ .Varint = .Simple }), + .IDHCLDDENHB = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODOFJLOOIHF = struct { + FKLGIFLGPLO: ArrayList(u32), + exp: u32 = 0, + level: u32 = 0, + FBNEHOBFJNP: u32 = 0, + FJOIJLHIIHO: ArrayList(u32), + IMMDGJFIAMC: u32 = 0, + + pub const _desc_table = .{ + .FKLGIFLGPLO = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .exp = fd(5, .{ .Varint = .Simple }), + .level = fd(9, .{ .Varint = .Simple }), + .FBNEHOBFJNP = fd(14, .{ .Varint = .Simple }), + .FJOIJLHIIHO = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .IMMDGJFIAMC = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const APIENLPHFCN = struct { + LOCNDHLENNO: ArrayList(ODOFJLOOIHF), + KHOFMPHEFNC: ArrayList(IKKLLNLEPDF), + buff_list: ArrayList(ABGIMIMBJHI), + PKCPJMCBKPB: ArrayList(CABEFCJFAGI), + + pub const _desc_table = .{ + .LOCNDHLENNO = fd(6, .{ .List = .{ .SubMessage = {} } }), + .KHOFMPHEFNC = fd(9, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + .PKCPJMCBKPB = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLMMKPMHHBD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetRogueHandbookDataScRsp = struct { + retcode: u32 = 0, + handbook_info: ?APIENLPHFCN = null, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .handbook_info = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENPGMNLPGAN = struct { + BNJFABDDPJJ: ArrayList(IKKLLNLEPDF), + CHFAJOMCMCJ: ArrayList(CABEFCJFAGI), + LILCKKGNLBG: ArrayList(ABGIMIMBJHI), + + pub const _desc_table = .{ + .BNJFABDDPJJ = fd(13, .{ .List = .{ .SubMessage = {} } }), + .CHFAJOMCMCJ = fd(9, .{ .List = .{ .SubMessage = {} } }), + .LILCKKGNLBG = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLPAGNJFNPC = struct { + HDANFHLJFEJ: ArrayList(u32), + + pub const _desc_table = .{ + .HDANFHLJFEJ = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGPODGBGBFF = struct { + HGEBLEMNBEO: ArrayList(u32), + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .HGEBLEMNBEO = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(10, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JGDKOMIGHMB = struct { + LPHHOBCLJDI: ArrayList(u32), + + pub const _desc_table = .{ + .LPHHOBCLJDI = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNIPOCBMJPJ = struct { + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + EKBDKOGPLMG: ArrayList(u32), + + pub const _desc_table = .{ + .ADKJIIANOOM = fd(14, .{ .SubMessage = {} }), + .retcode = fd(8, .{ .Varint = .Simple }), + .EKBDKOGPLMG = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBHIKMPLCKJ = struct { + MANBHCKBDBH: ArrayList(MANBHCKBDBHEntry), + + pub const _desc_table = .{ + .MANBHCKBDBH = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const MANBHCKBDBHEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ACEDGPNONMM = struct { + IGFKGOFCPAO: u32 = 0, + FPGMAJOGPGG: ?ICNMLEMMHKL = null, + KNIDGHHDIKJ: i32 = 0, + + pub const _desc_table = .{ + .IGFKGOFCPAO = fd(13, .{ .Varint = .Simple }), + .FPGMAJOGPGG = fd(3, .{ .SubMessage = {} }), + .KNIDGHHDIKJ = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMJBEONDHHG = struct { + KLDGPPEPGFA: ArrayList(u32), + + pub const _desc_table = .{ + .KLDGPPEPGFA = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMJKAOHLEHC = struct { + PLLLDFLFBFA: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .PLLLDFLFBFA = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDEDIPOBJEN = struct { + DNNNDJCADJE: ?IKHJMMFFDFD = null, + LDMGIHBCHBL: ?LGPKGFPBGMK = null, + IPFGCJHKCCG: ?HBHIKMPLCKJ = null, + ODEHLKCFDIJ: ?ACEDGPNONMM = null, + PNDBNEBJACA: ?EMJBEONDHHG = null, + BIEKDJAPPOI: ?ECPKADOCDID = null, + FINIAGDDFEP: ?GDPJIKHEAJE = null, + JGHAOFCGEMP: ?CMJKAOHLEHC = null, + + pub const _desc_table = .{ + .DNNNDJCADJE = fd(2, .{ .SubMessage = {} }), + .LDMGIHBCHBL = fd(10, .{ .SubMessage = {} }), + .IPFGCJHKCCG = fd(15, .{ .SubMessage = {} }), + .ODEHLKCFDIJ = fd(13, .{ .SubMessage = {} }), + .PNDBNEBJACA = fd(11, .{ .SubMessage = {} }), + .BIEKDJAPPOI = fd(7, .{ .SubMessage = {} }), + .FINIAGDDFEP = fd(14, .{ .SubMessage = {} }), + .JGHAOFCGEMP = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BAMJBGEIOLB = struct { + ADJAEKJAIBI: u32 = 0, + CGMDGOMHBNL: u32 = 0, + NNLELKHHBCL: u32 = 0, + GCBMCEAHIFC: ArrayList(GDEDIPOBJEN), + KEDAFILEAHI: u32 = 0, + + pub const _desc_table = .{ + .ADJAEKJAIBI = fd(10, .{ .Varint = .Simple }), + .CGMDGOMHBNL = fd(11, .{ .Varint = .Simple }), + .NNLELKHHBCL = fd(3, .{ .Varint = .Simple }), + .GCBMCEAHIFC = fd(6, .{ .List = .{ .SubMessage = {} } }), + .KEDAFILEAHI = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const RogueUnlockProgress = struct { + finish: bool = false, + progress: u32 = 0, + unlock_id: u32 = 0, + + pub const _desc_table = .{ + .finish = fd(9, .{ .Varint = .Simple }), + .progress = fd(1, .{ .Varint = .Simple }), + .unlock_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JHOOKGKGAAP = struct { + KBJMNKPIBJH: u32 = 0, + status: DHGHLLIDAKE = @enumFromInt(0), + FDJEDKGKCIL: ArrayList(RogueUnlockProgress), + + pub const _desc_table = .{ + .KBJMNKPIBJH = fd(12, .{ .Varint = .Simple }), + .status = fd(7, .{ .Varint = .Simple }), + .FDJEDKGKCIL = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EAHAIFANGDL = struct { + NAAPIPMJGKC: ArrayList(JHOOKGKGAAP), + + pub const _desc_table = .{ + .NAAPIPMJGKC = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EAFPGOBAMEP = struct { + ALNBPGMIHBM: u32 = 0, + HEGFEBADONJ: u32 = 0, + + pub const _desc_table = .{ + .ALNBPGMIHBM = fd(3, .{ .Varint = .Simple }), + .HEGFEBADONJ = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IGACOFNDNMA = struct { + PILMONIMDDJ: ArrayList(EAFPGOBAMEP), + + pub const _desc_table = .{ + .PILMONIMDDJ = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFHPJIMOLGA = struct { + MKBKNALIMBF: u32 = 0, + JFJLMPHCBFK: u32 = 0, + IHEEMHIELML: u32 = 0, + + pub const _desc_table = .{ + .MKBKNALIMBF = fd(14, .{ .Varint = .Simple }), + .JFJLMPHCBFK = fd(2, .{ .Varint = .Simple }), + .IHEEMHIELML = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNIHMPMFMOO = struct { + OGLBBEHHDKC: ArrayList(JNOCIOGHICG), + + pub const _desc_table = .{ + .OGLBBEHHDKC = fd(4, .{ .List = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKMFMOOECOL = struct { + BOJFAPKEFLD: ?CFHPJIMOLGA = null, + IMJLPHEJMBB: ?LNIHMPMFMOO = null, + + pub const _desc_table = .{ + .BOJFAPKEFLD = fd(1, .{ .SubMessage = {} }), + .IMJLPHEJMBB = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCKDADIAELP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLOHEBEMECB = struct { + DINGJPLIJKG: ?GKMFMOOECOL = null, + GGKHBEAJABI: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DINGJPLIJKG = fd(6, .{ .SubMessage = {} }), + .GGKHBEAJABI = fd(5, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGFMHNNMGKE = struct { + BOJFAPKEFLD: ?CFHPJIMOLGA = null, + IMJLPHEJMBB: ?LNIHMPMFMOO = null, + + pub const _desc_table = .{ + .BOJFAPKEFLD = fd(9, .{ .SubMessage = {} }), + .IMJLPHEJMBB = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEMCFOLEMMI = struct { + PLADOEMBODM: u32 = 0, + KCDGGBHJOMF: u32 = 0, + + pub const _desc_table = .{ + .PLADOEMBODM = fd(4, .{ .Varint = .Simple }), + .KCDGGBHJOMF = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIACKBJMGOM = struct { + LHMPHPEODNP: u32 = 0, + + pub const _desc_table = .{ + .LHMPHPEODNP = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NCAHFJEPBMO = struct { + LHMPHPEODNP: u32 = 0, + + pub const _desc_table = .{ + .LHMPHPEODNP = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBEPEJDDBHK = struct { + GCBLDBNEIDB: u32 = 0, + + pub const _desc_table = .{ + .GCBLDBNEIDB = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BGEPBKAMMOB = struct { + MGCGGNNIGCE: ?BEMCFOLEMMI = null, + IECFCBIHCKG: ?DIACKBJMGOM = null, + IBOEDGKFLIH: ?NCAHFJEPBMO = null, + HCNKEAOPIGF: ?CBEPEJDDBHK = null, + + pub const _desc_table = .{ + .MGCGGNNIGCE = fd(13, .{ .SubMessage = {} }), + .IECFCBIHCKG = fd(6, .{ .SubMessage = {} }), + .IBOEDGKFLIH = fd(1, .{ .SubMessage = {} }), + .HCNKEAOPIGF = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFEEECKDILK = struct { + BBOAIAOEJFH: i32 = 0, + OFKHKPLBJFK: f32 = 0, + + pub const _desc_table = .{ + .BBOAIAOEJFH = fd(6, .{ .Varint = .Simple }), + .OFKHKPLBJFK = fd(10, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGAAGPJDOEA = struct { + DGGCAFCLPFB: u32 = 0, + + pub const _desc_table = .{ + .DGGCAFCLPFB = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJAHMDLNMAK = struct { + KGBAJDMFAEP: i32 = 0, + + pub const _desc_table = .{ + .KGBAJDMFAEP = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFCBGCJNNJA = struct { + PPNAPEDNKEF: ?AGAAGPJDOEA = null, + ACHLGHPPMNO: ?OJAHMDLNMAK = null, + + pub const _desc_table = .{ + .PPNAPEDNKEF = fd(11, .{ .SubMessage = {} }), + .ACHLGHPPMNO = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IMLIMPNKMBJ = struct { + MFNFDHAGAPH: u32 = 0, + BNKLPFGAGPE: ArrayList(EFCBGCJNNJA), + HJCJBIAGIAD: u32 = 0, + AAFBIGKBCOM: bool = false, + FABJGGDPPIO: bool = false, + FJOJLFMCPKP: ?LFEEECKDILK = null, + + pub const _desc_table = .{ + .MFNFDHAGAPH = fd(9, .{ .Varint = .Simple }), + .BNKLPFGAGPE = fd(8, .{ .List = .{ .SubMessage = {} } }), + .HJCJBIAGIAD = fd(6, .{ .Varint = .Simple }), + .AAFBIGKBCOM = fd(13, .{ .Varint = .Simple }), + .FABJGGDPPIO = fd(5, .{ .Varint = .Simple }), + .FJOJLFMCPKP = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHDHGGBHGCI = struct { + BAEKOMFFIJF: ArrayList(IMLIMPNKMBJ), + MGAMAECMLBA: u32 = 0, + PNILMCNHGGN: ?BGEPBKAMMOB = null, + + pub const _desc_table = .{ + .BAEKOMFFIJF = fd(1, .{ .List = .{ .SubMessage = {} } }), + .MGAMAECMLBA = fd(15, .{ .Varint = .Simple }), + .PNILMCNHGGN = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDLKLBLDMBM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAADNKMEKAC = struct { + PAFMIJCHJPH: ArrayList(GHDHGGBHGCI), + retcode: u32 = 0, + + pub const _desc_table = .{ + .PAFMIJCHJPH = fd(14, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJJBBPLDHGJ = struct { + MFNFDHAGAPH: u32 = 0, + MGAMAECMLBA: u32 = 0, + + pub const _desc_table = .{ + .MFNFDHAGAPH = fd(9, .{ .Varint = .Simple }), + .MGAMAECMLBA = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOLOLDKDDKJ = struct { + retcode: u32 = 0, + MFNFDHAGAPH: u32 = 0, + MGAMAECMLBA: u32 = 0, + MMDFEMGOIAI: bool = false, + INKMIAMKOMD: ArrayList(u32), + NNICDPADDBB: ?GHDHGGBHGCI = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .MFNFDHAGAPH = fd(10, .{ .Varint = .Simple }), + .MGAMAECMLBA = fd(12, .{ .Varint = .Simple }), + .MMDFEMGOIAI = fd(8, .{ .Varint = .Simple }), + .INKMIAMKOMD = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .NNICDPADDBB = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDBNNKELNMK = struct { + MGAMAECMLBA: u32 = 0, + + pub const _desc_table = .{ + .MGAMAECMLBA = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLGPFDFMKGF = struct { + retcode: u32 = 0, + MGAMAECMLBA: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .MGAMAECMLBA = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCLKMPJKENK = struct { + PAFMIJCHJPH: ArrayList(GHDHGGBHGCI), + + pub const _desc_table = .{ + .PAFMIJCHJPH = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFODCMLMOGN = struct { + MFNFDHAGAPH: u32 = 0, + MGAMAECMLBA: u32 = 0, + NNICDPADDBB: ?GHDHGGBHGCI = null, + AMBIPCLHAGD: ?IMLIMPNKMBJ = null, + + pub const _desc_table = .{ + .MFNFDHAGAPH = fd(7, .{ .Varint = .Simple }), + .MGAMAECMLBA = fd(3, .{ .Varint = .Simple }), + .NNICDPADDBB = fd(12, .{ .SubMessage = {} }), + .AMBIPCLHAGD = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCKJNIIIHDO = struct { + ADJAEKJAIBI: u32 = 0, + NNLELKHHBCL: u32 = 0, + KEDAFILEAHI: u32 = 0, + DMCCBFECFEB: ?GDEDIPOBJEN = null, + + pub const _desc_table = .{ + .ADJAEKJAIBI = fd(7, .{ .Varint = .Simple }), + .NNLELKHHBCL = fd(8, .{ .Varint = .Simple }), + .KEDAFILEAHI = fd(15, .{ .Varint = .Simple }), + .DMCCBFECFEB = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCIENGLMBEF = struct { + NNLELKHHBCL: u32 = 0, + CGMDGOMHBNL: u32 = 0, + FENFEHFCGPO: ?IMIKGILFCCI = null, + ADJAEKJAIBI: u32 = 0, + KEDAFILEAHI: u32 = 0, + + pub const _desc_table = .{ + .NNLELKHHBCL = fd(12, .{ .Varint = .Simple }), + .CGMDGOMHBNL = fd(15, .{ .Varint = .Simple }), + .FENFEHFCGPO = fd(14, .{ .SubMessage = {} }), + .ADJAEKJAIBI = fd(1, .{ .Varint = .Simple }), + .KEDAFILEAHI = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKOOHLOCMAN = struct { + prop_entity_id: u32 = 0, + KEIHELBLLDG: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(12, .{ .Varint = .Simple }), + .KEIHELBLLDG = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BACNOPPGOEI = struct { + MFJKHNLFFJE: ?CMPBKIENJNF = null, + retcode: u32 = 0, + KEIHELBLLDG: u32 = 0, + + pub const _desc_table = .{ + .MFJKHNLFFJE = fd(1, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + .KEIHELBLLDG = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMNKENKFIIB = struct { + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLBLALOHLJD = struct { + retcode: u32 = 0, + IGJKECEIHAI: ArrayList(IGJKECEIHAIEntry), + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .IGJKECEIHAI = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const IGJKECEIHAIEntry = struct { + key: u32 = 0, + value: ?CMPBKIENJNF = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMPBKIENJNF = struct { + HPPKDAHGDKE: ?GJJIBMLPBPP = null, + OJFHPMBGPCC: ?KFKAFAJGJFO = null, + GGCIMCAFHKL: ?JNNOFOOFGJC = null, + NGLNGALEBJD: ?MGKEPIFFDKK = null, + MJGIKHCEBOG: ?JMFCLCEJIJA = null, + + pub const _desc_table = .{ + .HPPKDAHGDKE = fd(2, .{ .SubMessage = {} }), + .OJFHPMBGPCC = fd(4, .{ .SubMessage = {} }), + .GGCIMCAFHKL = fd(11, .{ .SubMessage = {} }), + .NGLNGALEBJD = fd(12, .{ .SubMessage = {} }), + .MJGIKHCEBOG = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJJIBMLPBPP = struct { + COGLEOEKCDH: bool = false, + CKOBFPNJKGG: u32 = 0, + HFBKPOBHBIM: ?PEHCKCFABKB = null, + BHPODBHODHP: i32 = 0, + DOELMPDLLDN: u32 = 0, + + pub const _desc_table = .{ + .COGLEOEKCDH = fd(8, .{ .Varint = .Simple }), + .CKOBFPNJKGG = fd(9, .{ .Varint = .Simple }), + .HFBKPOBHBIM = fd(1, .{ .SubMessage = {} }), + .BHPODBHODHP = fd(15, .{ .Varint = .Simple }), + .DOELMPDLLDN = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFKAFAJGJFO = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + CKOBFPNJKGG: u32 = 0, + BHPODBHODHP: i32 = 0, + COGLEOEKCDH: bool = false, + DOELMPDLLDN: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(1, .{ .SubMessage = {} }), + .CKOBFPNJKGG = fd(2, .{ .Varint = .Simple }), + .BHPODBHODHP = fd(9, .{ .Varint = .Simple }), + .COGLEOEKCDH = fd(15, .{ .Varint = .Simple }), + .DOELMPDLLDN = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JNNOFOOFGJC = struct { + KLHAHOAAHLB: ArrayList(KLHAHOAAHLBEntry), + MHBDEBNNLMG: u32 = 0, + CGBOKCHHEGG: u32 = 0, + + pub const _desc_table = .{ + .KLHAHOAAHLB = fd(13, .{ .List = .{ .SubMessage = {} } }), + .MHBDEBNNLMG = fd(11, .{ .Varint = .Simple }), + .CGBOKCHHEGG = fd(12, .{ .Varint = .Simple }), + }; + + pub const KLHAHOAAHLBEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGKEPIFFDKK = struct { + JFBFNGOJGHI: ArrayList(JFBFNGOJGHIEntry), + DOELMPDLLDN: u32 = 0, + BHPODBHODHP: i32 = 0, + HFBKPOBHBIM: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .JFBFNGOJGHI = fd(8, .{ .List = .{ .SubMessage = {} } }), + .DOELMPDLLDN = fd(3, .{ .Varint = .Simple }), + .BHPODBHODHP = fd(14, .{ .Varint = .Simple }), + .HFBKPOBHBIM = fd(6, .{ .SubMessage = {} }), + }; + + pub const JFBFNGOJGHIEntry = struct { + key: u32 = 0, + value: bool = false, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMFCLCEJIJA = struct { + HFBKPOBHBIM: ?PEHCKCFABKB = null, + BHPODBHODHP: i32 = 0, + DOELMPDLLDN: u32 = 0, + + pub const _desc_table = .{ + .HFBKPOBHBIM = fd(10, .{ .SubMessage = {} }), + .BHPODBHODHP = fd(6, .{ .Varint = .Simple }), + .DOELMPDLLDN = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKGIGGGNMCD = struct { + BGOHDKLKLHO: ?JMHCFCNGIHI = null, + KEIHELBLLDG: u32 = 0, + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .BGOHDKLKLHO = fd(14, .{ .SubMessage = {} }), + .KEIHELBLLDG = fd(9, .{ .Varint = .Simple }), + .prop_entity_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MLOAFLJKOCN = struct { + retcode: u32 = 0, + MFJKHNLFFJE: ?CMPBKIENJNF = null, + KEIHELBLLDG: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .MFJKHNLFFJE = fd(10, .{ .SubMessage = {} }), + .KEIHELBLLDG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMHCFCNGIHI = struct { + HPPKDAHGDKE: ?EFDAAFEGFON = null, + OJFHPMBGPCC: ?IACLIPMJCFE = null, + GGCIMCAFHKL: ?DKINBNGMCJE = null, + NGLNGALEBJD: ?HKEEJIJMEKN = null, + MJGIKHCEBOG: ?BGNNAFICAHO = null, + + pub const _desc_table = .{ + .HPPKDAHGDKE = fd(6, .{ .SubMessage = {} }), + .OJFHPMBGPCC = fd(13, .{ .SubMessage = {} }), + .GGCIMCAFHKL = fd(11, .{ .SubMessage = {} }), + .NGLNGALEBJD = fd(8, .{ .SubMessage = {} }), + .MJGIKHCEBOG = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFDAAFEGFON = struct { + PCPCGDPAKNL: u32 = 0, + + pub const _desc_table = .{ + .PCPCGDPAKNL = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IACLIPMJCFE = struct { + NPGAHCANMAP: u32 = 0, + + pub const _desc_table = .{ + .NPGAHCANMAP = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DKINBNGMCJE = struct { + DAMJOEBEBPB: u32 = 0, + + pub const _desc_table = .{ + .DAMJOEBEBPB = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HKEEJIJMEKN = struct { + CBPLFBODDCL: ArrayList(u32), + + pub const _desc_table = .{ + .CBPLFBODDCL = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BGNNAFICAHO = struct { + NINCEAGHJLJ: u32 = 0, + + pub const _desc_table = .{ + .NINCEAGHJLJ = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMHBBMKDDKE = struct { + status: CLJMGCEBLCI = @enumFromInt(0), + LOEOCICFOPB: u32 = 0, + + pub const _desc_table = .{ + .status = fd(8, .{ .Varint = .Simple }), + .LOEOCICFOPB = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKMOBBCJPML = struct { + HKJLPJBINNM: u32 = 0, + status: GJHNLJFKIGE = @enumFromInt(0), + LOEOCICFOPB: u32 = 0, + + pub const _desc_table = .{ + .HKJLPJBINNM = fd(15, .{ .Varint = .Simple }), + .status = fd(12, .{ .Varint = .Simple }), + .LOEOCICFOPB = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGBKBJKHDEG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCFECINPPBH = struct { + COKIBHJMFBF: ArrayList(EMHBBMKDDKE), + retcode: u32 = 0, + AJNKEDBMANM: ArrayList(KKMOBBCJPML), + + pub const _desc_table = .{ + .COKIBHJMFBF = fd(15, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(1, .{ .Varint = .Simple }), + .AJNKEDBMANM = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPFOIOLGCBD = struct { + OKLIDHMFDPA: ArrayList(u32), + IKJCFGPFODN: ArrayList(u32), + GGALGBLFGCB: ArrayList(IPNEPEPBNKJ), + + pub const _desc_table = .{ + .OKLIDHMFDPA = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .IKJCFGPFODN = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .GGALGBLFGCB = fd(13, .{ .List = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDHOCKEEGKP = struct { + COKIBHJMFBF: ArrayList(EMHBBMKDDKE), + retcode: u32 = 0, + AJNKEDBMANM: ArrayList(KKMOBBCJPML), + + pub const _desc_table = .{ + .COKIBHJMFBF = fd(10, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(7, .{ .Varint = .Simple }), + .AJNKEDBMANM = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EMIECBDCBNM = struct { + status: JBBOKAOGBDI = @enumFromInt(0), + LNAIONDBECA: u32 = 0, + + pub const _desc_table = .{ + .status = fd(2, .{ .Varint = .Simple }), + .LNAIONDBECA = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGPEHIBFFCB = struct { + LNAIONDBECA: u32 = 0, + status: GJHNLJFKIGE = @enumFromInt(0), + HKJLPJBINNM: u32 = 0, + + pub const _desc_table = .{ + .LNAIONDBECA = fd(4, .{ .Varint = .Simple }), + .status = fd(3, .{ .Varint = .Simple }), + .HKJLPJBINNM = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NAADBFJPMMN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EGKHFMHBKLE = struct { + retcode: u32 = 0, + FMKFFPMHCPE: ArrayList(GGPEHIBFFCB), + JDBJENNKOBK: ArrayList(EMIECBDCBNM), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .FMKFFPMHCPE = fd(10, .{ .List = .{ .SubMessage = {} } }), + .JDBJENNKOBK = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EOKOCABFLLB = struct { + FKMOAFFHIMF: ArrayList(u32), + KOEMAFKEOIO: ArrayList(u32), + NMBJNBIBMKK: ArrayList(IPNEPEPBNKJ), + + pub const _desc_table = .{ + .FKMOAFFHIMF = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .KOEMAFKEOIO = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .NMBJNBIBMKK = fd(6, .{ .List = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOOBCJOODMA = struct { + JDBJENNKOBK: ArrayList(EMIECBDCBNM), + FMKFFPMHCPE: ArrayList(GGPEHIBFFCB), + retcode: u32 = 0, + + pub const _desc_table = .{ + .JDBJENNKOBK = fd(14, .{ .List = .{ .SubMessage = {} } }), + .FMKFFPMHCPE = fd(13, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOCPLFNHAMO = struct { + NDPAMBJKKFD: u32 = 0, + + pub const _desc_table = .{ + .NDPAMBJKKFD = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EGCJIFLCOKA = struct { + AECECHPBPFI: u32 = 0, + FJNNNFIDKNL: bool = false, + GPCPGEMLPGK: ?HOCPLFNHAMO = null, + + pub const _desc_table = .{ + .AECECHPBPFI = fd(13, .{ .Varint = .Simple }), + .FJNNNFIDKNL = fd(4, .{ .Varint = .Simple }), + .GPCPGEMLPGK = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONHDCOFMGDK = struct { + IPKGCMGPFMC: ArrayList(EGCJIFLCOKA), + IDEDFDAGKOA: bool = false, + group_id: u32 = 0, + + pub const _desc_table = .{ + .IPKGCMGPFMC = fd(5, .{ .List = .{ .SubMessage = {} } }), + .IDEDFDAGKOA = fd(6, .{ .Varint = .Simple }), + .group_id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JEKBCCABJBF = struct { + NINPGHJPOHF: bool = false, + CHNADPCAFGH: ?PEHCKCFABKB = null, + POGKAIEJDDM: u32 = 0, + KABNOGFDKFI: u32 = 0, + HFHJMIHIJGL: u32 = 0, + KBHGKNDFLLF: u32 = 0, + CHJJOALILPG: ArrayList(ONHDCOFMGDK), + + pub const _desc_table = .{ + .NINPGHJPOHF = fd(1, .{ .Varint = .Simple }), + .CHNADPCAFGH = fd(4, .{ .SubMessage = {} }), + .POGKAIEJDDM = fd(14, .{ .Varint = .Simple }), + .KABNOGFDKFI = fd(7, .{ .Varint = .Simple }), + .HFHJMIHIJGL = fd(6, .{ .Varint = .Simple }), + .KBHGKNDFLLF = fd(5, .{ .Varint = .Simple }), + .CHJJOALILPG = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FGMHEHIGLPM = struct { + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMEIHMDHKPE = struct { + AIODEBOEGDI: ?JEKBCCABJBF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .AIODEBOEGDI = fd(8, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJIAMEJFMBH = struct { + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDFMAEOPCFP = struct { + AIODEBOEGDI: ?JEKBCCABJBF = null, + KPNACLEMDNN: u32 = 0, + CEBHOKDHMPL: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .AIODEBOEGDI = fd(8, .{ .SubMessage = {} }), + .KPNACLEMDNN = fd(2, .{ .Varint = .Simple }), + .CEBHOKDHMPL = fd(9, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BEBEALGJPLI = struct { + CAIHLMOIFHG: ?BBLNDEMIPMI = null, + status: RogueStatus = @enumFromInt(0), + base_avatar_id_list: ArrayList(u32), + HANFDCIPMMD: ArrayList(u32), + GGHMFLALMKN: u32 = 0, + APJCIBOMJJC: ?FJBBJBIHOCP = null, + AHDIECBFBIF: u32 = 0, + GCAMGEFODNA: u32 = 0, + EGKOJHEIOHH: u32 = 0, + + pub const _desc_table = .{ + .CAIHLMOIFHG = fd(7, .{ .SubMessage = {} }), + .status = fd(11, .{ .Varint = .Simple }), + .base_avatar_id_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .HANFDCIPMMD = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .GGHMFLALMKN = fd(15, .{ .Varint = .Simple }), + .APJCIBOMJJC = fd(12, .{ .SubMessage = {} }), + .AHDIECBFBIF = fd(8, .{ .Varint = .Simple }), + .GCAMGEFODNA = fd(13, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODCBIMDGIKK = struct { + OJDKJMEMNLP: u32 = 0, + LADIFOHNBDH: bool = false, + IGJMMMJAMOI: u32 = 0, + battle_id: u32 = 0, + ADOIGGMBICA: u32 = 0, + JGFPDACBKLF: u32 = 0, + OFADMPJBBDL: u32 = 0, + ANGAKAOPOOG: u32 = 0, + + pub const _desc_table = .{ + .OJDKJMEMNLP = fd(10, .{ .Varint = .Simple }), + .LADIFOHNBDH = fd(12, .{ .Varint = .Simple }), + .IGJMMMJAMOI = fd(4, .{ .Varint = .Simple }), + .battle_id = fd(11, .{ .Varint = .Simple }), + .ADOIGGMBICA = fd(9, .{ .Varint = .Simple }), + .JGFPDACBKLF = fd(1, .{ .Varint = .Simple }), + .OFADMPJBBDL = fd(2, .{ .Varint = .Simple }), + .ANGAKAOPOOG = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IIMHELOPCJP = struct { + EBMHKKEENEB: ?BEBEALGJPLI = null, + ONBDKKFHLAO: u32 = 0, + KKNKBPJBFML: ?ODCBIMDGIKK = null, + ABEDIGLKNCF: u32 = 0, + + pub const _desc_table = .{ + .EBMHKKEENEB = fd(13, .{ .SubMessage = {} }), + .ONBDKKFHLAO = fd(4, .{ .Varint = .Simple }), + .KKNKBPJBFML = fd(14, .{ .SubMessage = {} }), + .ABEDIGLKNCF = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLFMHLAJCPB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLGCEIMMIIE = struct { + IPOJGPBKKPD: u32 = 0, + LJNCNGJCLCM: u32 = 0, + retcode: u32 = 0, + data: ArrayList(IIMHELOPCJP), + PCHNKJDMAAO: ArrayList(u32), + + pub const _desc_table = .{ + .IPOJGPBKKPD = fd(13, .{ .Varint = .Simple }), + .LJNCNGJCLCM = fd(8, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + .data = fd(14, .{ .List = .{ .SubMessage = {} } }), + .PCHNKJDMAAO = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JACLKNHEFLK = struct { + avatar_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(15, .{ .Varint = .Simple }), + .avatar_type = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJGOEBDAKJC = struct { + avatar_list: ArrayList(JACLKNHEFLK), + KCIECPEKLAB: u32 = 0, + + pub const _desc_table = .{ + .avatar_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .KCIECPEKLAB = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EBPJOJLBCON = struct { + KKNKBPJBFML: ?ODCBIMDGIKK = null, + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .KKNKBPJBFML = fd(15, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + .battle_info = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CAPNJDHGIKI = struct { + KKNKBPJBFML: ?ODCBIMDGIKK = null, + + pub const _desc_table = .{ + .KKNKBPJBFML = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGNJKANLNCG = struct { + level: u32 = 0, + HFEDJFGPNOH: bool = false, + + pub const _desc_table = .{ + .level = fd(5, .{ .Varint = .Simple }), + .HFEDJFGPNOH = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JMCKPJAOJCB = struct { + PCHNKJDMAAO: ArrayList(u32), + ADKJIIANOOM: ?ItemList = null, + level: u32 = 0, + HFEDJFGPNOH: bool = false, + IPOJGPBKKPD: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .PCHNKJDMAAO = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .ADKJIIANOOM = fd(7, .{ .SubMessage = {} }), + .level = fd(2, .{ .Varint = .Simple }), + .HFEDJFGPNOH = fd(11, .{ .Varint = .Simple }), + .IPOJGPBKKPD = fd(8, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDLGOBAPMFB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOBEPLCCFMO = struct { + retcode: u32 = 0, + PCHNKJDMAAO: ArrayList(u32), + ADKJIIANOOM: ?ItemList = null, + IPOJGPBKKPD: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .PCHNKJDMAAO = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .ADKJIIANOOM = fd(14, .{ .SubMessage = {} }), + .IPOJGPBKKPD = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNHEJOKEJMH = struct { + BGKOLAODLEA: u32 = 0, + LGOKPIPOJLM: u32 = 0, + AAFBIGKBCOM: bool = false, + + pub const _desc_table = .{ + .BGKOLAODLEA = fd(1, .{ .Varint = .Simple }), + .LGOKPIPOJLM = fd(13, .{ .Varint = .Simple }), + .AAFBIGKBCOM = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JPHDOJOCIDF = struct { + BGKOLAODLEA: u32 = 0, + NBPFOAAFCAN: ArrayList(u32), + LGOKPIPOJLM: u32 = 0, + AAFBIGKBCOM: bool = false, + + pub const _desc_table = .{ + .BGKOLAODLEA = fd(4, .{ .Varint = .Simple }), + .NBPFOAAFCAN = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .LGOKPIPOJLM = fd(3, .{ .Varint = .Simple }), + .AAFBIGKBCOM = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBCPFAGEMJO = struct { + BGKOLAODLEA: u32 = 0, + NBPFOAAFCAN: ArrayList(u32), + AAFBIGKBCOM: bool = false, + + pub const _desc_table = .{ + .BGKOLAODLEA = fd(13, .{ .Varint = .Simple }), + .NBPFOAAFCAN = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .AAFBIGKBCOM = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJEJAPBNACA = struct { + BGKOLAODLEA: u32 = 0, + DPFKLCPPMPA: ArrayList(u32), + MOCGKFIGAPC: u32 = 0, + AAFBIGKBCOM: bool = false, + + pub const _desc_table = .{ + .BGKOLAODLEA = fd(11, .{ .Varint = .Simple }), + .DPFKLCPPMPA = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .MOCGKFIGAPC = fd(4, .{ .Varint = .Simple }), + .AAFBIGKBCOM = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMICMEMFHNI = struct { + DDMHOKOAAIH: u32 = 0, + + pub const _desc_table = .{ + .DDMHOKOAAIH = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLCNLHHOIBL = struct { + OEEGEHECJCB: u32 = 0, + + pub const _desc_table = .{ + .OEEGEHECJCB = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EABBKBCINBH = struct { + BPONJFKOHBF: u32 = 0, + + pub const _desc_table = .{ + .BPONJFKOHBF = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKEJKKJPJEE = struct { + AAFBIGKBCOM: bool = false, + DPFKLCPPMPA: ArrayList(u32), + BGKOLAODLEA: u32 = 0, + BICGKJHDPNJ: u32 = 0, + + pub const _desc_table = .{ + .AAFBIGKBCOM = fd(7, .{ .Varint = .Simple }), + .DPFKLCPPMPA = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .BGKOLAODLEA = fd(13, .{ .Varint = .Simple }), + .BICGKJHDPNJ = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NIOPBGOGIPO = struct { + HPAJOGCGOAJ: u32 = 0, + OGGAKNDMIKO: u32 = 0, + ACHHCJCGOGB: u32 = 0, + + pub const _desc_table = .{ + .HPAJOGCGOAJ = fd(15, .{ .Varint = .Simple }), + .OGGAKNDMIKO = fd(5, .{ .Varint = .Simple }), + .ACHHCJCGOGB = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CNFPIJMMDFG = struct { + IFDKIEDBFAE: u32 = 0, + + pub const _desc_table = .{ + .IFDKIEDBFAE = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GLPFECNNDKJ = struct { + DJOAJNAHOKB: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .DJOAJNAHOKB = fd(8, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FAAPOGOHEKM = struct { + OJHPHFGLNGF: u32 = 0, + NHFGFOCFGCG: u32 = 0, + PBCNFIPMMDL: u32 = 0, + + pub const _desc_table = .{ + .OJHPHFGLNGF = fd(6, .{ .Varint = .Simple }), + .NHFGFOCFGCG = fd(5, .{ .Varint = .Simple }), + .PBCNFIPMMDL = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ACDPMONKEIN = struct { + NHFGFOCFGCG: u32 = 0, + CBIBHDJIOKK: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(11, .{ .Varint = .Simple }), + .CBIBHDJIOKK = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANFCIDCJOMJ = struct { + DDMHOKOAAIH: u32 = 0, + + pub const _desc_table = .{ + .DDMHOKOAAIH = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIKOFACLAEM = struct { + LGOKPIPOJLM: u32 = 0, + + pub const _desc_table = .{ + .LGOKPIPOJLM = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OGHKAGEDFGH = struct { + NBPFOAAFCAN: ArrayList(u32), + AAFBIGKBCOM: bool = false, + BGKOLAODLEA: u32 = 0, + + pub const _desc_table = .{ + .NBPFOAAFCAN = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .AAFBIGKBCOM = fd(12, .{ .Varint = .Simple }), + .BGKOLAODLEA = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BINIPLHCGFP = struct { + IFDKIEDBFAE: u32 = 0, + LMFKPODHKAP: u32 = 0, + + pub const _desc_table = .{ + .IFDKIEDBFAE = fd(10, .{ .Varint = .Simple }), + .LMFKPODHKAP = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EJHPOIJDKFI = struct { + GFBNDBDBDAO: u32 = 0, + BEGDCLPFCEH: NGOLGIGLBJG = @enumFromInt(0), + BKIEKCHKBHH: u32 = 0, + + pub const _desc_table = .{ + .GFBNDBDBDAO = fd(5, .{ .Varint = .Simple }), + .BEGDCLPFCEH = fd(12, .{ .Varint = .Simple }), + .BKIEKCHKBHH = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPMEFMNHIHE = struct { + MIHPCGKIKIA: ArrayList(u32), + BGKOLAODLEA: u32 = 0, + AAFBIGKBCOM: bool = false, + + pub const _desc_table = .{ + .MIHPCGKIKIA = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .BGKOLAODLEA = fd(12, .{ .Varint = .Simple }), + .AAFBIGKBCOM = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JKBHAJIFAAJ = struct { + NLNHMAPCOBI: u32 = 0, + + pub const _desc_table = .{ + .NLNHMAPCOBI = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCJOMJPELAM = struct { + count: u32 = 0, + + pub const _desc_table = .{ + .count = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GOOFAJHLCEE = struct { + FPDIJECJJMF: ?EJHPOIJDKFI = null, + GMFANAAJFAB: u64 = 0, + AJMBMJDJEJJ: ILKJJKFPFHC = @enumFromInt(0), + MCHNNHFIEBG: ?KPMEFMNHIHE = null, + + pub const _desc_table = .{ + .FPDIJECJJMF = fd(4, .{ .SubMessage = {} }), + .GMFANAAJFAB = fd(12, .{ .Varint = .Simple }), + .AJMBMJDJEJJ = fd(11, .{ .Varint = .Simple }), + .MCHNNHFIEBG = fd(1044, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICNMLEMMHKL = struct { + BCLODKIFEBJ: ArrayList(GOOFAJHLCEE), + + pub const _desc_table = .{ + .BCLODKIFEBJ = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKFJCNBJDPJ = struct { + CALJLCIMLPF: ?GOOFAJHLCEE = null, + + pub const _desc_table = .{ + .CALJLCIMLPF = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADBCGLHHBEG = struct { + JLJIKLDHIJE: u32 = 0, + + pub const _desc_table = .{ + .JLJIKLDHIJE = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFLMJCCOKDC = struct { + retcode: u32 = 0, + IMOJCCEGMMM: ?ItemList = null, + JLJIKLDHIJE: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .IMOJCCEGMMM = fd(9, .{ .SubMessage = {} }), + .JLJIKLDHIJE = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAIEDFHNOKK = struct { + CALJLCIMLPF: ?GOOFAJHLCEE = null, + + pub const _desc_table = .{ + .CALJLCIMLPF = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IEOOJBLBANK = struct { + GMFANAAJFAB: u64 = 0, + + pub const _desc_table = .{ + .GMFANAAJFAB = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBKDHMBKGJI = struct { + AJMBMJDJEJJ: ILKJJKFPFHC = @enumFromInt(0), + + pub const _desc_table = .{ + .AJMBMJDJEJJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMGHEFGMHFO = struct { + scene: ?SceneInfo = null, + lineup: ?LineupInfo = null, + BENPBCFBKLF: ?ADFICOFDKCG = null, + + pub const _desc_table = .{ + .scene = fd(13, .{ .SubMessage = {} }), + .lineup = fd(2, .{ .SubMessage = {} }), + .BENPBCFBKLF = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAFFDHMFIGA = struct { + LJJCNKNOAJO: ?OCIENGLMBEF = null, + BOCBHGEAPPG: ?NPDDMDDLHOO = null, + + pub const _desc_table = .{ + .LJJCNKNOAJO = fd(11, .{ .SubMessage = {} }), + .BOCBHGEAPPG = fd(1538, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PECNIJEAIIB = struct { + JPNEJHFMMPM: u32 = 0, + DMCKDHLIKDC: u32 = 0, + HNFEIDJPLJK: bool = false, + CCOMNNIHGDP: u32 = 0, + + pub const _desc_table = .{ + .JPNEJHFMMPM = fd(8, .{ .Varint = .Simple }), + .DMCKDHLIKDC = fd(10, .{ .Varint = .Simple }), + .HNFEIDJPLJK = fd(5, .{ .Varint = .Simple }), + .CCOMNNIHGDP = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMBLGECBIBP = struct { + KEJHMBALBGN: u32 = 0, + OMKOINCNCCB: u32 = 0, + HNFEIDJPLJK: bool = false, + ONFHCNGNINF: u32 = 0, + + pub const _desc_table = .{ + .KEJHMBALBGN = fd(12, .{ .Varint = .Simple }), + .OMKOINCNCCB = fd(9, .{ .Varint = .Simple }), + .HNFEIDJPLJK = fd(14, .{ .Varint = .Simple }), + .ONFHCNGNINF = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJIAHGOOHAD = struct { + EPHBCKFNBKI: u32 = 0, + HNFEIDJPLJK: bool = false, + IOLKELHHLPP: u32 = 0, + + pub const _desc_table = .{ + .EPHBCKFNBKI = fd(13, .{ .Varint = .Simple }), + .HNFEIDJPLJK = fd(12, .{ .Varint = .Simple }), + .IOLKELHHLPP = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ALONKPBGLGI = struct { + FHEJLMFKNHC: bool = false, + + pub const _desc_table = .{ + .FHEJLMFKNHC = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPDDMDDLHOO = struct { + PFKIOEPNOII: ?LGPKGFPBGMK = null, + MGDBKFOACHM: ?GDPJIKHEAJE = null, + CLCAABAPOFC: ?HBHIKMPLCKJ = null, + NGEMJMBKOGK: ?ECPKADOCDID = null, + level: ?OHOELDDBAHK = null, + ONAIHEPGDKM: ?ALONKPBGLGI = null, + CEIOBEAGGPK: ?JFBELHFLNAA = null, + MCIBAOIDNIO: ?GHKBGNFCEDK = null, + lineup: ?CMJKAOHLEHC = null, + NCIGBGIDJPE: ?IKHJMMFFDFD = null, + + pub const _desc_table = .{ + .PFKIOEPNOII = fd(13, .{ .SubMessage = {} }), + .MGDBKFOACHM = fd(2, .{ .SubMessage = {} }), + .CLCAABAPOFC = fd(3, .{ .SubMessage = {} }), + .NGEMJMBKOGK = fd(6, .{ .SubMessage = {} }), + .level = fd(11, .{ .SubMessage = {} }), + .ONAIHEPGDKM = fd(5, .{ .SubMessage = {} }), + .CEIOBEAGGPK = fd(10, .{ .SubMessage = {} }), + .MCIBAOIDNIO = fd(14, .{ .SubMessage = {} }), + .lineup = fd(15, .{ .SubMessage = {} }), + .NCIGBGIDJPE = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHOELDDBAHK = struct { + JBALMPCEPMF: u32 = 0, + AHBANIDFGEC: ArrayList(HGAHBBJIPMI), + NLEFHGHGKPE: LPKALADMPND = @enumFromInt(0), + status: GIOJDCJKCEL = @enumFromInt(0), + + pub const _desc_table = .{ + .JBALMPCEPMF = fd(9, .{ .Varint = .Simple }), + .AHBANIDFGEC = fd(14, .{ .List = .{ .SubMessage = {} } }), + .NLEFHGHGKPE = fd(13, .{ .Varint = .Simple }), + .status = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JFBELHFLNAA = struct { + HECINLIEPFL: u32 = 0, + DBABAJHEDKL: u32 = 0, + + pub const _desc_table = .{ + .HECINLIEPFL = fd(5, .{ .Varint = .Simple }), + .DBABAJHEDKL = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHKBGNFCEDK = struct { + KLDGPPEPGFA: ArrayList(u32), + + pub const _desc_table = .{ + .KLDGPPEPGFA = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HGAHBBJIPMI = struct { + BGEKODBBLNK: ArrayList(GAKIPIKJKJE), + GIKEKGKEEMB: u32 = 0, + DIOBGDMACPB: u32 = 0, + HCAOIINOLDN: u32 = 0, + status: DMMGENFFCHJ = @enumFromInt(0), + + pub const _desc_table = .{ + .BGEKODBBLNK = fd(4, .{ .List = .{ .SubMessage = {} } }), + .GIKEKGKEEMB = fd(9, .{ .Varint = .Simple }), + .DIOBGDMACPB = fd(3, .{ .Varint = .Simple }), + .HCAOIINOLDN = fd(7, .{ .Varint = .Simple }), + .status = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GAKIPIKJKJE = struct { + AONJIMKFFEB: u32 = 0, + LOPNFDJHCLN: u32 = 0, + status: GJAJOJLOHEJ = @enumFromInt(0), + MHAAMKIPFMH: u32 = 0, + + pub const _desc_table = .{ + .AONJIMKFFEB = fd(9, .{ .Varint = .Simple }), + .LOPNFDJHCLN = fd(11, .{ .Varint = .Simple }), + .status = fd(6, .{ .Varint = .Simple }), + .MHAAMKIPFMH = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DBKGKCANAHJ = struct { + IAHJJAIDIFN: ArrayList(u32), + ONBDKKFHLAO: u32 = 0, + base_avatar_id_list: ArrayList(u32), + PHHHAAHMHDE: u32 = 0, + + pub const _desc_table = .{ + .IAHJJAIDIFN = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .ONBDKKFHLAO = fd(6, .{ .Varint = .Simple }), + .base_avatar_id_list = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .PHHHAAHMHDE = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBDEIDIFCHF = struct { + retcode: u32 = 0, + IMGCICPCMIC: ?MMGHEFGMHFO = null, + PHHHAAHMHDE: u32 = 0, + LLACLOMHIMO: ?KAFFDHMFIGA = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .IMGCICPCMIC = fd(8, .{ .SubMessage = {} }), + .PHHHAAHMHDE = fd(13, .{ .Varint = .Simple }), + .LLACLOMHIMO = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIAMOKECMMB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFAKNLBFAPH = struct { + IMGCICPCMIC: ?MMGHEFGMHFO = null, + LLACLOMHIMO: ?KAFFDHMFIGA = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMGCICPCMIC = fd(10, .{ .SubMessage = {} }), + .LLACLOMHIMO = fd(2, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GEPAGALPMGJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHMMIBJONPO = struct { + IMGCICPCMIC: ?MMGHEFGMHFO = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMGCICPCMIC = fd(15, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPPILGKIHPI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOBLHLMIDAE = struct { + COENPLNMMOH: ?FMBLGECBIBP = null, + OGAAFEIKNON: ?PECNIJEAIIB = null, + LLACLOMHIMO: ?KAFFDHMFIGA = null, + JGHAOFCGEMP: ?LineupInfo = null, + BFIGBKDHIGJ: ?CJIAHGOOHAD = null, + + pub const _desc_table = .{ + .COENPLNMMOH = fd(6, .{ .SubMessage = {} }), + .OGAAFEIKNON = fd(15, .{ .SubMessage = {} }), + .LLACLOMHIMO = fd(5, .{ .SubMessage = {} }), + .JGHAOFCGEMP = fd(11, .{ .SubMessage = {} }), + .BFIGBKDHIGJ = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HJECFIBAEJL = struct { + retcode: u32 = 0, + BDBFLHCAHGP: ?IOBLHLMIDAE = null, + IMGCICPCMIC: ?MMGHEFGMHFO = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .BDBFLHCAHGP = fd(12, .{ .SubMessage = {} }), + .IMGCICPCMIC = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKOEEIIDBMI = struct { + FFDFGAPLGFP: u32 = 0, + DIOBGDMACPB: u32 = 0, + + pub const _desc_table = .{ + .FFDFGAPLGFP = fd(10, .{ .Varint = .Simple }), + .DIOBGDMACPB = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NNODLEIMLFO = struct { + IMGCICPCMIC: ?MMGHEFGMHFO = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMGCICPCMIC = fd(6, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPGEEABLKMO = struct { + JBALMPCEPMF: u32 = 0, + FFDFGAPLGFP: u32 = 0, + + pub const _desc_table = .{ + .JBALMPCEPMF = fd(10, .{ .Varint = .Simple }), + .FFDFGAPLGFP = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHLDLOOOGDE = struct { + IMGCICPCMIC: ?MMGHEFGMHFO = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMGCICPCMIC = fd(14, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCANLKLNOLL = struct { + status: GIOJDCJKCEL = @enumFromInt(0), + JBALMPCEPMF: u32 = 0, + NLEFHGHGKPE: LPKALADMPND = @enumFromInt(0), + AHBANIDFGEC: ArrayList(HGAHBBJIPMI), + + pub const _desc_table = .{ + .status = fd(1, .{ .Varint = .Simple }), + .JBALMPCEPMF = fd(5, .{ .Varint = .Simple }), + .NLEFHGHGKPE = fd(12, .{ .Varint = .Simple }), + .AHBANIDFGEC = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCOPNAANGMG = struct { + MNDMBFEPHAH: ArrayList(u32), + JFBHBOCCCFE: u32 = 0, + + pub const _desc_table = .{ + .MNDMBFEPHAH = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .JFBHBOCCCFE = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EKFHAFEJMEN = struct { + retcode: u32 = 0, + AFBKBHHNGCG: ArrayList(u32), + ADKJIIANOOM: ?ItemList = null, + exp: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(1, .{ .Varint = .Simple }), + .AFBKBHHNGCG = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .ADKJIIANOOM = fd(12, .{ .SubMessage = {} }), + .exp = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MKIBKPDECIO = struct { + exp: u32 = 0, + + pub const _desc_table = .{ + .exp = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKLLLOFHBMI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJCDLJMNKMI = struct { + ALLBNFAACKE: ArrayList(u32), + INKBNPPGBLO: bool = false, + MBEDCLKGPEA: bool = false, + PIJAIMBBNPG: bool = false, + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .ALLBNFAACKE = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .INKBNPPGBLO = fd(6, .{ .Varint = .Simple }), + .MBEDCLKGPEA = fd(8, .{ .Varint = .Simple }), + .PIJAIMBBNPG = fd(9, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDNPEMNGPBI = struct { + end_time: i64 = 0, + DGILGDCOABA: bool = false, + PHHHAAHMHDE: u32 = 0, + FKFHGBAFJOG: u32 = 0, + + pub const _desc_table = .{ + .end_time = fd(11, .{ .Varint = .Simple }), + .DGILGDCOABA = fd(6, .{ .Varint = .Simple }), + .PHHHAAHMHDE = fd(1, .{ .Varint = .Simple }), + .FKFHGBAFJOG = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BLDJADCPPHE = struct { + exp: u32 = 0, + AFBKBHHNGCG: ArrayList(u32), + + pub const _desc_table = .{ + .exp = fd(13, .{ .Varint = .Simple }), + .AFBKBHHNGCG = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BDICIJOOFIJ = struct { + GHCJGBFCGHH: ?EAHAIFANGDL = null, + CJLNIGBKFIH: u32 = 0, + + pub const _desc_table = .{ + .GHCJGBFCGHH = fd(12, .{ .SubMessage = {} }), + .CJLNIGBKFIH = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJBLPLDABEJ = struct { + PIJAIMBBNPG: bool = false, + GNDHILGBMCJ: u32 = 0, + + pub const _desc_table = .{ + .PIJAIMBBNPG = fd(4, .{ .Varint = .Simple }), + .GNDHILGBMCJ = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELIJGBJIMIE = struct { + JFBHBOCCCFE: u32 = 0, + BOJDCMKMFAN: u32 = 0, + + pub const _desc_table = .{ + .JFBHBOCCCFE = fd(11, .{ .Varint = .Simple }), + .BOJDCMKMFAN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AMFIPGIPFID = struct { + HLDFMBHOBJK: ArrayList(u32), + KGGMJCEEJOO: ArrayList(u32), + LPHHOBCLJDI: ArrayList(u32), + LHDLBLANLCH: ArrayList(u32), + OLDDBHMECAG: ArrayList(u32), + ONPBIAFFJJK: u32 = 0, + + pub const _desc_table = .{ + .HLDFMBHOBJK = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .KGGMJCEEJOO = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .LPHHOBCLJDI = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .LHDLBLANLCH = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .OLDDBHMECAG = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .ONPBIAFFJJK = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBNOJIMNGDN = struct { + DNFOKCGBBBC: ?AMFIPGIPFID = null, + KMGFDAKHGPJ: ?BDICIJOOFIJ = null, + HCKCDDJAMFA: ?BLDJADCPPHE = null, + KMKEADAKIBP: ?EDNPEMNGPBI = null, + JNAJDKAGOIA: ArrayList(JJCDLJMNKMI), + MNBBKFEPOCA: ArrayList(FJBLPLDABEJ), + BBKPGHACNEL: ArrayList(IHIAKMDDPIB), + JIOMIEGFHJE: ?ELIJGBJIMIE = null, + + pub const _desc_table = .{ + .DNFOKCGBBBC = fd(5, .{ .SubMessage = {} }), + .KMGFDAKHGPJ = fd(2, .{ .SubMessage = {} }), + .HCKCDDJAMFA = fd(1, .{ .SubMessage = {} }), + .KMKEADAKIBP = fd(11, .{ .SubMessage = {} }), + .JNAJDKAGOIA = fd(4, .{ .List = .{ .SubMessage = {} } }), + .MNBBKFEPOCA = fd(3, .{ .List = .{ .SubMessage = {} } }), + .BBKPGHACNEL = fd(15, .{ .List = .{ .SubMessage = {} } }), + .JIOMIEGFHJE = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MAAKABJJCMM = struct { + DINGJPLIJKG: ?FBNOJIMNGDN = null, + LLACLOMHIMO: ?KAFFDHMFIGA = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DINGJPLIJKG = fd(14, .{ .SubMessage = {} }), + .LLACLOMHIMO = fd(1, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKMKKNDHNOC = struct { + JNAJDKAGOIA: ArrayList(JJCDLJMNKMI), + + pub const _desc_table = .{ + .JNAJDKAGOIA = fd(8, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IHIAKMDDPIB = struct { + KFIMJFGJLMM: u32 = 0, + time: i64 = 0, + JIOMIEGFHJE: ?ELIJGBJIMIE = null, + end_time: i64 = 0, + name: ManagedString = .Empty, + LLACLOMHIMO: ?KAFFDHMFIGA = null, + data: ?JHMIILIPJNA = null, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(7, .{ .Varint = .Simple }), + .time = fd(2, .{ .Varint = .Simple }), + .JIOMIEGFHJE = fd(4, .{ .SubMessage = {} }), + .end_time = fd(8, .{ .Varint = .Simple }), + .name = fd(14, .String), + .LLACLOMHIMO = fd(15, .{ .SubMessage = {} }), + .data = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JHMIILIPJNA = struct { + buff_list: ArrayList(JHALLHFNDEH), + PKCPJMCBKPB: ArrayList(KDBKEEFGCGF), + CLCAABAPOFC: u32 = 0, + + pub const _desc_table = .{ + .buff_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + .PKCPJMCBKPB = fd(3, .{ .List = .{ .SubMessage = {} } }), + .CLCAABAPOFC = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCIKEINEOGP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCMJKIHJCKC = struct { + retcode: u32 = 0, + EHHLMNMPAJM: ArrayList(IHIAKMDDPIB), + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .EHHLMNMPAJM = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BPOBELLHCML = struct { + KFIMJFGJLMM: u32 = 0, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIDNBJFEICH = struct { + retcode: u32 = 0, + KFIMJFGJLMM: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .KFIMJFGJLMM = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJIECEFAGPK = struct { + KFIMJFGJLMM: u32 = 0, + name: ManagedString = .Empty, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(3, .{ .Varint = .Simple }), + .name = fd(6, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOCNFGAHHBI = struct { + KFIMJFGJLMM: u32 = 0, + retcode: u32 = 0, + name: ManagedString = .Empty, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(11, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .name = fd(6, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJDHIJCNHHA = struct { + KFIMJFGJLMM: u32 = 0, + + pub const _desc_table = .{ + .KFIMJFGJLMM = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BJLIPINNMCB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CPDPKMDODPG = struct { + retcode: u32 = 0, + KMGFDAKHGPJ: ?BDICIJOOFIJ = null, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .KMGFDAKHGPJ = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPNNNNFGOCO = struct { + KBJMNKPIBJH: u32 = 0, + + pub const _desc_table = .{ + .KBJMNKPIBJH = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPIPDCLEDBN = struct { + KMGFDAKHGPJ: ?BDICIJOOFIJ = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .KMGFDAKHGPJ = fd(5, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMEIEGDCOGP = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPELOFHCDKG = struct { + KMGFDAKHGPJ: ?BDICIJOOFIJ = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .KMGFDAKHGPJ = fd(5, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNLPGPMFPGC = struct { + NDPJNKLHOHE: u32 = 0, + PMKBCMKOGEN: u32 = 0, + HLNFDPNENGO: bool = false, + avatar_list: ArrayList(MBPEFDFDAHO), + GPEEOECJNDA: u32 = 0, + + pub const _desc_table = .{ + .NDPJNKLHOHE = fd(8, .{ .Varint = .Simple }), + .PMKBCMKOGEN = fd(2, .{ .Varint = .Simple }), + .HLNFDPNENGO = fd(10, .{ .Varint = .Simple }), + .avatar_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .GPEEOECJNDA = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCOKFCFKCOL = struct { + retcode: u32 = 0, + IMGCICPCMIC: ?MMGHEFGMHFO = null, + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .IMGCICPCMIC = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDABIGONPFG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHAHKMFCLFE = struct { + IMGCICPCMIC: ?MMGHEFGMHFO = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMGCICPCMIC = fd(1, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCANADADOKO = struct { + HLNFDPNENGO: bool = false, + + pub const _desc_table = .{ + .HLNFDPNENGO = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HBMCKJDPDBJ = struct { + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .battle_info = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJKBOFOMONA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDGBKFPKBAA = struct { + PMKBCMKOGEN: u32 = 0, + NDPJNKLHOHE: u32 = 0, + retcode: u32 = 0, + GPEEOECJNDA: u32 = 0, + + pub const _desc_table = .{ + .PMKBCMKOGEN = fd(12, .{ .Varint = .Simple }), + .NDPJNKLHOHE = fd(5, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .GPEEOECJNDA = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEIFMPJEBAP = struct { + LFIDOKMBKLH: ArrayList(u32), + + pub const _desc_table = .{ + .LFIDOKMBKLH = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPNEHNEKCFN = struct { + EONMHEBMIDH: LOEOAHCPNEN = @enumFromInt(0), + GNOCKAOHNFJ: ArrayList(u32), + + pub const _desc_table = .{ + .EONMHEBMIDH = fd(1, .{ .Varint = .Simple }), + .GNOCKAOHNFJ = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EALCGFGCGCO = struct { + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .ONBDKKFHLAO = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDMDBNMKBPL = struct { + retcode: u32 = 0, + BDBFLHCAHGP: ?IOBLHLMIDAE = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .BDBFLHCAHGP = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHCMIHEMPLC = struct { + name: ManagedString = .Empty, + KFIMJFGJLMM: u32 = 0, + ONBDKKFHLAO: u32 = 0, + + pub const _desc_table = .{ + .name = fd(15, .String), + .KFIMJFGJLMM = fd(9, .{ .Varint = .Simple }), + .ONBDKKFHLAO = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJNDPHFADAE = struct { + retcode: u32 = 0, + LMAJLLHDAJH: ?IHIAKMDDPIB = null, + CMGCABDODON: ?ItemList = null, + IMGCICPCMIC: ?MMGHEFGMHFO = null, + IGGBDLKDAFL: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .LMAJLLHDAJH = fd(4, .{ .SubMessage = {} }), + .CMGCABDODON = fd(5, .{ .SubMessage = {} }), + .IMGCICPCMIC = fd(10, .{ .SubMessage = {} }), + .IGGBDLKDAFL = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFNBLBEPPEL = struct { + KMKEADAKIBP: ?EDNPEMNGPBI = null, + + pub const _desc_table = .{ + .KMKEADAKIBP = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AELLEKHJPHH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNHBMBLKJHH = struct { + BFIGBKDHIGJ: ?CJIAHGOOHAD = null, + OGAAFEIKNON: ?PECNIJEAIIB = null, + COENPLNMMOH: ?FMBLGECBIBP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .BFIGBKDHIGJ = fd(14, .{ .SubMessage = {} }), + .OGAAFEIKNON = fd(11, .{ .SubMessage = {} }), + .COENPLNMMOH = fd(3, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNMEELNOKBD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDMGDHMODJN = struct { + MFJPKEAIFID: ArrayList(u32), + LPFJJLPMIFK: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .MFJPKEAIFID = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .LPFJJLPMIFK = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGCMBFOGJLK = struct { + PLLLDFLFBFA: ?PEHCKCFABKB = null, + + pub const _desc_table = .{ + .PLLLDFLFBFA = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MFLNPBAIICF = struct { + base_avatar_id_list: ArrayList(u32), + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .base_avatar_id_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .LDOLLOOEIKA = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GJKFDJGMFFK = struct { + PLLLDFLFBFA: ?PEHCKCFABKB = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .PLLLDFLFBFA = fd(14, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFDIMKMFKIC = struct { + IMGCICPCMIC: ?MMGHEFGMHFO = null, + BDBFLHCAHGP: ?IOBLHLMIDAE = null, + + pub const _desc_table = .{ + .IMGCICPCMIC = fd(15, .{ .SubMessage = {} }), + .BDBFLHCAHGP = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHLODLJFAEJ = struct { + INKADMICLLH: u32 = 0, + + pub const _desc_table = .{ + .INKADMICLLH = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKFBDOLGCDJ = struct { + PBMHFIONKEA: ArrayList(u32), + retcode: u32 = 0, + LGLBPKOCIFK: u32 = 0, + INKADMICLLH: u32 = 0, + + pub const _desc_table = .{ + .PBMHFIONKEA = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(14, .{ .Varint = .Simple }), + .LGLBPKOCIFK = fd(9, .{ .Varint = .Simple }), + .INKADMICLLH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMEALGFONHN = struct { + CFLJILLNELC: u32 = 0, + INKADMICLLH: u32 = 0, + LGLBPKOCIFK: u32 = 0, + + pub const _desc_table = .{ + .CFLJILLNELC = fd(13, .{ .Varint = .Simple }), + .INKADMICLLH = fd(11, .{ .Varint = .Simple }), + .LGLBPKOCIFK = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ACKNMGMHPEL = struct { + retcode: u32 = 0, + INKADMICLLH: u32 = 0, + EJAPJPIDPOA: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + MIKJCKGDJCK: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .INKADMICLLH = fd(11, .{ .Varint = .Simple }), + .EJAPJPIDPOA = fd(15, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(3, .{ .SubMessage = {} }), + .MIKJCKGDJCK = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJGPEJNIHKM = struct { + INKADMICLLH: u32 = 0, + + pub const _desc_table = .{ + .INKADMICLLH = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const TakeRollShopRewardScRsp = struct { + group_type: u32 = 0, + retcode: u32 = 0, + roll_shop_id: u32 = 0, + reward: ?ItemList = null, + + pub const _desc_table = .{ + .group_type = fd(11, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + .roll_shop_id = fd(14, .{ .Varint = .Simple }), + .reward = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneActorInfo = struct { + avatar_type: AvatarType = @enumFromInt(0), + base_avatar_id: u32 = 0, + map_layer: u32 = 0, + uid: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(2, .{ .Varint = .Simple }), + .base_avatar_id = fd(11, .{ .Varint = .Simple }), + .map_layer = fd(9, .{ .Varint = .Simple }), + .uid = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNHLBJJNNLG = struct { + BIGJKGHBGAH: u32 = 0, + + pub const _desc_table = .{ + .BIGJKGHBGAH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ONMJBNNOBFJ = struct { + BHEIMEPJINE: ?MNHLBJJNNLG = null, + + pub const _desc_table = .{ + .BHEIMEPJINE = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneNpcMonsterInfo = struct { + KIEDGNHHBMA: bool = false, + world_level: u32 = 0, + monster_id: u32 = 0, + DNCKDNCOOAB: bool = false, + event_id: u32 = 0, + extra_info: ?ONMJBNNOBFJ = null, + + pub const _desc_table = .{ + .KIEDGNHHBMA = fd(6, .{ .Varint = .Simple }), + .world_level = fd(8, .{ .Varint = .Simple }), + .monster_id = fd(10, .{ .Varint = .Simple }), + .DNCKDNCOOAB = fd(1, .{ .Varint = .Simple }), + .event_id = fd(13, .{ .Varint = .Simple }), + .extra_info = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGOANECDEHK = struct { + MNHMNDGAEIE: u32 = 0, + HJCJBIAGIAD: u32 = 0, + + pub const _desc_table = .{ + .MNHMNDGAEIE = fd(12, .{ .Varint = .Simple }), + .HJCJBIAGIAD = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HIACMGHPPMI = struct { + JOFMIKFBGHP: bool = false, + PLADOEMBODM: u32 = 0, + KCDGGBHJOMF: u32 = 0, + CLFMCIDHJLM: bool = false, + JFCBEHNMGNO: bool = false, + OENLKDCLEOA: u32 = 0, + FKDHDCGOIMF: ArrayList(FKDHDCGOIMFEntry), + MGAMAECMLBA: u32 = 0, + HNICHMNGJBJ: ArrayList(KGOANECDEHK), + + pub const _desc_table = .{ + .JOFMIKFBGHP = fd(9, .{ .Varint = .Simple }), + .PLADOEMBODM = fd(11, .{ .Varint = .Simple }), + .KCDGGBHJOMF = fd(12, .{ .Varint = .Simple }), + .CLFMCIDHJLM = fd(15, .{ .Varint = .Simple }), + .JFCBEHNMGNO = fd(1, .{ .Varint = .Simple }), + .OENLKDCLEOA = fd(2, .{ .Varint = .Simple }), + .FKDHDCGOIMF = fd(8, .{ .List = .{ .SubMessage = {} } }), + .MGAMAECMLBA = fd(4, .{ .Varint = .Simple }), + .HNICHMNGJBJ = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const FKDHDCGOIMFEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AALAHNDEPBA = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECHLHJALCKL = struct { + GLLBNLGPJAE: bool = false, + KKHCGIBNEED: u32 = 0, + LCIHGFGAEAI: u32 = 0, + + pub const _desc_table = .{ + .GLLBNLGPJAE = fd(13, .{ .Varint = .Simple }), + .KKHCGIBNEED = fd(12, .{ .Varint = .Simple }), + .LCIHGFGAEAI = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NpcExtraInfo = struct { + BHEIMEPJINE: ?HIACMGHPPMI = null, + KEILALKHCCA: ?ECHLHJALCKL = null, + OLGAOBHACKD: ?AALAHNDEPBA = null, + + pub const _desc_table = .{ + .BHEIMEPJINE = fd(7, .{ .SubMessage = {} }), + .KEILALKHCCA = fd(6, .{ .SubMessage = {} }), + .OLGAOBHACKD = fd(14, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneNpcInfo = struct { + extra_info: ?NpcExtraInfo = null, + npc_id: u32 = 0, + + pub const _desc_table = .{ + .extra_info = fd(7, .{ .SubMessage = {} }), + .npc_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropRogueInfo = struct { + DLNBFLGDKHP: u32 = 0, + HOLMCCNOAAK: u32 = 0, + LOPNFDJHCLN: u32 = 0, + HHNMDAKKDPD: u32 = 0, + + pub const _desc_table = .{ + .DLNBFLGDKHP = fd(12, .{ .Varint = .Simple }), + .HOLMCCNOAAK = fd(4, .{ .Varint = .Simple }), + .LOPNFDJHCLN = fd(8, .{ .Varint = .Simple }), + .HHNMDAKKDPD = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropAeonInfo = struct { + aeon_id: u32 = 0, + dialogue_group_id: u32 = 0, + add_exp: u32 = 0, + + pub const _desc_table = .{ + .aeon_id = fd(13, .{ .Varint = .Simple }), + .dialogue_group_id = fd(5, .{ .Varint = .Simple }), + .add_exp = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropChessRogueInfo = struct { + AFLGOJIEAKE: bool = false, + GFPNICCINGC: bool = false, + + pub const _desc_table = .{ + .AFLGOJIEAKE = fd(11, .{ .Varint = .Simple }), + .GFPNICCINGC = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropRogueTournDoorInfo = struct { + NFGHKABPDHB: u32 = 0, + KKIHGEIFIME: bool = false, + MHAAMKIPFMH: u32 = 0, + + pub const _desc_table = .{ + .NFGHKABPDHB = fd(4, .{ .Varint = .Simple }), + .KKIHGEIFIME = fd(6, .{ .Varint = .Simple }), + .MHAAMKIPFMH = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LGJJLABMONN = struct { + FABJGGDPPIO: bool = false, + KEIHELBLLDG: u32 = 0, + + pub const _desc_table = .{ + .FABJGGDPPIO = fd(2, .{ .Varint = .Simple }), + .KEIHELBLLDG = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropRogueTournWorkbenchInfo = struct { + JMAKJGDHNDB: ArrayList(LGJJLABMONN), + DNHHFMCBDAD: u32 = 0, + + pub const _desc_table = .{ + .JMAKJGDHNDB = fd(4, .{ .List = .{ .SubMessage = {} } }), + .DNHHFMCBDAD = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropRogueGambleMachineInfo = struct { + AIODEBOEGDI: ?JEKBCCABJBF = null, + CICGEOEAOBF: u32 = 0, + + pub const _desc_table = .{ + .AIODEBOEGDI = fd(13, .{ .SubMessage = {} }), + .CICGEOEAOBF = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropRogueCurseChestInfo = struct { + JHMOFNALMPO: u32 = 0, + + pub const _desc_table = .{ + .JHMOFNALMPO = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PropExtraInfo = struct { + info: ?info_union, + + pub const _info_case = enum { + rogue_info, + aeon_info, + chess_rogue_info, + rogue_tourn_door_info, + rogue_tourn_workbench_info, + rogue_gamble_machine_info, + rogue_curse_chest_info, + }; + pub const info_union = union(_info_case) { + rogue_info: PropRogueInfo, + aeon_info: PropAeonInfo, + chess_rogue_info: PropChessRogueInfo, + rogue_tourn_door_info: PropRogueTournDoorInfo, + rogue_tourn_workbench_info: PropRogueTournWorkbenchInfo, + rogue_gamble_machine_info: PropRogueGambleMachineInfo, + rogue_curse_chest_info: PropRogueCurseChestInfo, + pub const _union_desc = .{ + .rogue_info = fd(11, .{ .SubMessage = {} }), + .aeon_info = fd(9, .{ .SubMessage = {} }), + .chess_rogue_info = fd(8, .{ .SubMessage = {} }), + .rogue_tourn_door_info = fd(13, .{ .SubMessage = {} }), + .rogue_tourn_workbench_info = fd(1, .{ .SubMessage = {} }), + .rogue_gamble_machine_info = fd(10, .{ .SubMessage = {} }), + .rogue_curse_chest_info = fd(6, .{ .SubMessage = {} }), + }; + }; + + pub const _desc_table = .{ + .info = fd(null, .{ .OneOf = info_union }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ScenePropInfo = struct { + extra_info: ?PropExtraInfo = null, + prop_state: u32 = 0, + prop_id: u32 = 0, + create_time_ms: u64 = 0, + HIEIDIPFNMN: ArrayList(ManagedString), + life_time_ms: u32 = 0, + + pub const _desc_table = .{ + .extra_info = fd(7, .{ .SubMessage = {} }), + .prop_state = fd(9, .{ .Varint = .Simple }), + .prop_id = fd(6, .{ .Varint = .Simple }), + .create_time_ms = fd(2, .{ .Varint = .Simple }), + .HIEIDIPFNMN = fd(15, .{ .List = .String }), + .life_time_ms = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneSummonUnitInfo = struct { + HIEIDIPFNMN: ArrayList(ManagedString), + life_time_ms: i32 = 0, + KADBHDIAEOE: u32 = 0, + GEOEIBPBPLA: u32 = 0, + GEEKOBFDDCK: u32 = 0, + create_time_ms: u64 = 0, + + pub const _desc_table = .{ + .HIEIDIPFNMN = fd(6, .{ .List = .String }), + .life_time_ms = fd(15, .{ .Varint = .Simple }), + .KADBHDIAEOE = fd(4, .{ .Varint = .Simple }), + .GEOEIBPBPLA = fd(10, .{ .Varint = .Simple }), + .GEEKOBFDDCK = fd(14, .{ .Varint = .Simple }), + .create_time_ms = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneEntityInfo = struct { + inst_id: u32 = 0, + motion: ?MotionInfo = null, + group_id: u32 = 0, + entity_id: u32 = 0, + entity: ?entity_union, + + pub const _entity_case = enum { + actor, + npc_monster, + npc, + prop, + summon_unit, + }; + pub const entity_union = union(_entity_case) { + actor: SceneActorInfo, + npc_monster: SceneNpcMonsterInfo, + npc: SceneNpcInfo, + prop: ScenePropInfo, + summon_unit: SceneSummonUnitInfo, + pub const _union_desc = .{ + .actor = fd(6, .{ .SubMessage = {} }), + .npc_monster = fd(2, .{ .SubMessage = {} }), + .npc = fd(5, .{ .SubMessage = {} }), + .prop = fd(10, .{ .SubMessage = {} }), + .summon_unit = fd(15, .{ .SubMessage = {} }), + }; + }; + + pub const _desc_table = .{ + .inst_id = fd(8, .{ .Varint = .Simple }), + .motion = fd(13, .{ .SubMessage = {} }), + .group_id = fd(14, .{ .Varint = .Simple }), + .entity_id = fd(4, .{ .Varint = .Simple }), + .entity = fd(null, .{ .OneOf = entity_union }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BuffInfo = struct { + count: u32 = 0, + add_time_ms: u64 = 0, + base_avatar_id: u32 = 0, + dynamic_values: ArrayList(DynamicValuesEntry), + JFEIFDFAHEB: u32 = 0, + NOJPMGONLPN: u32 = 0, + level: u32 = 0, + life_time: f32 = 0, + + pub const _desc_table = .{ + .count = fd(8, .{ .Varint = .Simple }), + .add_time_ms = fd(15, .{ .Varint = .Simple }), + .base_avatar_id = fd(5, .{ .Varint = .Simple }), + .dynamic_values = fd(4, .{ .List = .{ .SubMessage = {} } }), + .JFEIFDFAHEB = fd(13, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(3, .{ .Varint = .Simple }), + .level = fd(7, .{ .Varint = .Simple }), + .life_time = fd(11, .{ .FixedInt = .I32 }), + }; + + pub const DynamicValuesEntry = struct { + key: ManagedString = .Empty, + value: f32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .FixedInt = .I32 }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EntityBuffInfo = struct { + buff_list: ArrayList(BuffInfo), + entity_id: u32 = 0, + + pub const _desc_table = .{ + .buff_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .entity_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECOEGMPKEFC = struct { + value: u32 = 0, + CKIEABAOHNP: u32 = 0, + + pub const _desc_table = .{ + .value = fd(11, .{ .Varint = .Simple }), + .CKIEABAOHNP = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLKMPCJLPMI = struct { + BDPJKLJKDDN: ManagedString = .Empty, + group_id: u32 = 0, + + pub const _desc_table = .{ + .BDPJKLJKDDN = fd(2, .String), + .group_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKCHJEFEPNF = struct { + COCFIFOINGL: u32 = 0, + BMDAJFCOEBI: u32 = 0, + + pub const _desc_table = .{ + .COCFIFOINGL = fd(14, .{ .Varint = .Simple }), + .BMDAJFCOEBI = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneGroupInfo = struct { + state: u32 = 0, + entity_list: ArrayList(SceneEntityInfo), + group_id: u32 = 0, + + pub const _desc_table = .{ + .state = fd(6, .{ .Varint = .Simple }), + .entity_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + .group_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFMGIPBNDKD = struct { + state: u32 = 0, + GNDLIKMGDJB: bool = false, + group_id: u32 = 0, + + pub const _desc_table = .{ + .state = fd(6, .{ .Varint = .Simple }), + .GNDLIKMGDJB = fd(2, .{ .Varint = .Simple }), + .group_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PFGPGKFEPHG = struct { + LIGBGCHHGCK: ArrayList(u32), + HMEBLKIBOMA: ArrayList(Mission), + FCGAAJNEEML: ArrayList(PACCCGPFMOF), + JKBKCPMNHKL: ArrayList(u32), + FBOGBEPMILE: ArrayList(u32), + + pub const _desc_table = .{ + .LIGBGCHHGCK = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .HMEBLKIBOMA = fd(3, .{ .List = .{ .SubMessage = {} } }), + .FCGAAJNEEML = fd(15, .{ .List = .{ .SubMessage = {} } }), + .JKBKCPMNHKL = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .FBOGBEPMILE = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneInfo = struct { + lighten_section_list: ArrayList(u32), + CGNPDOCKDIB: ArrayList(CGNPDOCKDIBEntry), + entity_list: ArrayList(SceneEntityInfo), + FGHNDKIDHLF: u32 = 0, + GMIGBLFHHAO: u32 = 0, + entity_buff_list: ArrayList(EntityBuffInfo), + env_buff_list: ArrayList(BuffInfo), + EADDBEBEJPO: u32 = 0, + MFLMHFABPJF: ArrayList(MFLMHFABPJFEntry), + IGMHNGBCCJC: ArrayList(u32), + BOCEAHMENHD: u32 = 0, + plane_id: u32 = 0, + IBBALBCDDII: ArrayList(OLKMPCJLPMI), + DFLJHOMMGOO: ?PFGPGKFEPHG = null, + game_mode_type: u32 = 0, + interact_id: u32 = 0, + floor_id: u32 = 0, + scene_group_list: ArrayList(SceneGroupInfo), + DMCEECKMCOB: ArrayList(BFMGIPBNDKD), + entry_id: u32 = 0, + LCOELBMMICB: u32 = 0, + + pub const _desc_table = .{ + .lighten_section_list = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .CGNPDOCKDIB = fd(3, .{ .List = .{ .SubMessage = {} } }), + .entity_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .FGHNDKIDHLF = fd(15, .{ .Varint = .Simple }), + .GMIGBLFHHAO = fd(739, .{ .Varint = .Simple }), + .entity_buff_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + .env_buff_list = fd(11, .{ .List = .{ .SubMessage = {} } }), + .EADDBEBEJPO = fd(14, .{ .Varint = .Simple }), + .MFLMHFABPJF = fd(317, .{ .List = .{ .SubMessage = {} } }), + .IGMHNGBCCJC = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .BOCEAHMENHD = fd(1997, .{ .Varint = .Simple }), + .plane_id = fd(5, .{ .Varint = .Simple }), + .IBBALBCDDII = fd(13, .{ .List = .{ .SubMessage = {} } }), + .DFLJHOMMGOO = fd(622, .{ .SubMessage = {} }), + .game_mode_type = fd(10, .{ .Varint = .Simple }), + .interact_id = fd(12, .{ .Varint = .Simple }), + .floor_id = fd(7, .{ .Varint = .Simple }), + .scene_group_list = fd(203, .{ .List = .{ .SubMessage = {} } }), + .DMCEECKMCOB = fd(1274, .{ .List = .{ .SubMessage = {} } }), + .entry_id = fd(6, .{ .Varint = .Simple }), + .LCOELBMMICB = fd(267, .{ .Varint = .Simple }), + }; + + pub const CGNPDOCKDIBEntry = struct { + key: u32 = 0, + value: ?FKCHJEFEPNF = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const MFLMHFABPJFEntry = struct { + key: ManagedString = .Empty, + value: i32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EntityMotion = struct { + AAIDFKGPPPB: bool = false, + entity_id: u32 = 0, + motion: ?MotionInfo = null, + map_layer: u32 = 0, + + pub const _desc_table = .{ + .AAIDFKGPPPB = fd(10, .{ .Varint = .Simple }), + .entity_id = fd(4, .{ .Varint = .Simple }), + .motion = fd(15, .{ .SubMessage = {} }), + .map_layer = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneEntityMoveCsReq = struct { + KHIGKLJENKH: u64 = 0, + entry_id: u32 = 0, + entity_motion_list: ArrayList(EntityMotion), + + pub const _desc_table = .{ + .KHIGKLJENKH = fd(8, .{ .Varint = .Simple }), + .entry_id = fd(11, .{ .Varint = .Simple }), + .entity_motion_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneEntityMoveScRsp = struct { + entity_motion_list: ArrayList(EntityMotion), + download_data: ?ClientDownloadData = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .entity_motion_list = fd(13, .{ .List = .{ .SubMessage = {} } }), + .download_data = fd(4, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const InteractPropCsReq = struct { + interact_id: u32 = 0, + entity_id: u32 = 0, + motion: ?MotionInfo = null, + entry_id: u32 = 0, + + pub const _desc_table = .{ + .interact_id = fd(10, .{ .Varint = .Simple }), + .entity_id = fd(11, .{ .Varint = .Simple }), + .motion = fd(4, .{ .SubMessage = {} }), + .entry_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCIDNDPFPJE = struct { + GFEBOGHDMOP: u32 = 0, + + pub const _desc_table = .{ + .GFEBOGHDMOP = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMMJJMPACNE = struct { + DEPOJLPMAAH: u32 = 0, + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .DEPOJLPMAAH = fd(13, .{ .Varint = .Simple }), + .prop_entity_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const InteractPropScRsp = struct { + prop_entity_id: u32 = 0, + prop_state: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(10, .{ .Varint = .Simple }), + .prop_state = fd(2, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJNBMJOMPJK = struct { + MAFPMCMCHEN: MonsterBattleType = @enumFromInt(0), + OMDLKEEFGDP: u32 = 0, + + pub const _desc_table = .{ + .MAFPMCMCHEN = fd(7, .{ .Varint = .Simple }), + .OMDLKEEFGDP = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABJCBAOKICE = struct { + value: f32 = 0, + MBBNDDLBEPE: ManagedString = .Empty, + + pub const _desc_table = .{ + .value = fd(8, .{ .FixedInt = .I32 }), + .MBBNDDLBEPE = fd(10, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGHMFJGHCGI = struct { + OLNOHBLOFPM: ArrayList(u32), + + pub const _desc_table = .{ + .OLNOHBLOFPM = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneCastSkillCsReq = struct { + LFHDFMJDKMN: u32 = 0, + IMEFCMMHNID: u32 = 0, + CDIHMLNGNFF: ArrayList(DGHMFJGHCGI), + dynamic_values: ArrayList(ABJCBAOKICE), + skill_index: u32 = 0, + IGGFLDMBDKC: ?MotionInfo = null, + PAFJIFMHMKI: ArrayList(u32), + JDEHKOHBCOJ: u32 = 0, + JEJALNGCHIG: ArrayList(SceneCastSkillType), + HJFNCLOKAON: ArrayList(u32), + + pub const _desc_table = .{ + .LFHDFMJDKMN = fd(3, .{ .Varint = .Simple }), + .IMEFCMMHNID = fd(10, .{ .Varint = .Simple }), + .CDIHMLNGNFF = fd(4, .{ .List = .{ .SubMessage = {} } }), + .dynamic_values = fd(11, .{ .List = .{ .SubMessage = {} } }), + .skill_index = fd(15, .{ .Varint = .Simple }), + .IGGFLDMBDKC = fd(12, .{ .SubMessage = {} }), + .PAFJIFMHMKI = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .JDEHKOHBCOJ = fd(13, .{ .Varint = .Simple }), + .JEJALNGCHIG = fd(5, .{ .List = .{ .Varint = .Simple } }), + .HJFNCLOKAON = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneCastSkillScRsp = struct { + battle_info: ?SceneBattleInfo = null, + IMEFCMMHNID: u32 = 0, + retcode: u32 = 0, + OBOFJBEEOMA: ArrayList(PJNBMJOMPJK), + + pub const _desc_table = .{ + .battle_info = fd(9, .{ .SubMessage = {} }), + .IMEFCMMHNID = fd(6, .{ .Varint = .Simple }), + .retcode = fd(2, .{ .Varint = .Simple }), + .OBOFJBEEOMA = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCOJHBLPGCI = struct { + IMEFCMMHNID: u32 = 0, + skill_index: u32 = 0, + JDEHKOHBCOJ: u32 = 0, + + pub const _desc_table = .{ + .IMEFCMMHNID = fd(10, .{ .Varint = .Simple }), + .skill_index = fd(15, .{ .Varint = .Simple }), + .JDEHKOHBCOJ = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DOHNPAPKEOJ = struct { + IMEFCMMHNID: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .IMEFCMMHNID = fd(2, .{ .Varint = .Simple }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EANEDFGEAFC = struct { + HGBHBGMMOKG: u32 = 0, + IMEFCMMHNID: u32 = 0, + + pub const _desc_table = .{ + .HGBHBGMMOKG = fd(4, .{ .Varint = .Simple }), + .IMEFCMMHNID = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneEnterStageCsReq = struct { + event_id: u32 = 0, + COEMOEECAEM: OICCDGCAPKG = @enumFromInt(0), + FAOBCNGOEFD: bool = false, + + pub const _desc_table = .{ + .event_id = fd(4, .{ .Varint = .Simple }), + .COEMOEECAEM = fd(15, .{ .Varint = .Simple }), + .FAOBCNGOEFD = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneEnterStageScRsp = struct { + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .battle_info = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOIMIAAAHPE = struct { + COEMOEECAEM: OICCDGCAPKG = @enumFromInt(0), + + pub const _desc_table = .{ + .COEMOEECAEM = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAEJPCPADKM = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetCurSceneInfoCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetCurSceneInfoScRsp = struct { + scene: ?SceneInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .scene = fd(3, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DFMJJAPBDIJ = struct { + NLEFHGHGKPE: SceneEntityBuffChangeType = @enumFromInt(0), + LLNEDFNGBAD: ?BuffInfo = null, + AIEABOMMABO: u32 = 0, + entity_id: u32 = 0, + + pub const _desc_table = .{ + .NLEFHGHGKPE = fd(4, .{ .Varint = .Simple }), + .LLNEDFNGBAD = fd(5, .{ .SubMessage = {} }), + .AIEABOMMABO = fd(15, .{ .Varint = .Simple }), + .entity_id = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const INGMBBBNCNJ = struct { + GBGCHGEAGOF: ArrayList(DFMJJAPBDIJ), + + pub const _desc_table = .{ + .GBGCHGEAGOF = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpringRefreshCsReq = struct { + floor_id: u32 = 0, + plane_id: u32 = 0, + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .floor_id = fd(10, .{ .Varint = .Simple }), + .plane_id = fd(14, .{ .Varint = .Simple }), + .prop_entity_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpringRefreshScRsp = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDBLOBCEKJA = struct { + KAIGEMHIEFH: i64 = 0, + + pub const _desc_table = .{ + .KAIGEMHIEFH = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DJCDMDGKHMM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNBKLMBCMKJ = struct { + scene: ?SceneInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .scene = fd(10, .{ .SubMessage = {} }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LEPPJFJMCFB = struct { + MANNEKNIHFO: u32 = 0, + + pub const _desc_table = .{ + .MANNEKNIHFO = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMHCADPPLMA = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AAPCHIDEECI = struct { + entity_id: u32 = 0, + + pub const _desc_table = .{ + .entity_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCFEJBMLNNP = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FNIDJGCNFBI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFLAHCCGGIN = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SavePointsInfoNotify = struct { + refresh_time: i64 = 0, + valid_times: u32 = 0, + + pub const _desc_table = .{ + .refresh_time = fd(12, .{ .Varint = .Simple }), + .valid_times = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const StartCocoonStageCsReq = struct { + prop_entity_id: u32 = 0, + cocoon_id: u32 = 0, + world_level: u32 = 0, + wave: u32 = 0, + + pub const _desc_table = .{ + .prop_entity_id = fd(11, .{ .Varint = .Simple }), + .cocoon_id = fd(14, .{ .Varint = .Simple }), + .world_level = fd(2, .{ .Varint = .Simple }), + .wave = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const StartCocoonStageScRsp = struct { + cocoon_id: u32 = 0, + wave: u32 = 0, + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .cocoon_id = fd(14, .{ .Varint = .Simple }), + .wave = fd(1, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + .battle_info = fd(6, .{ .SubMessage = {} }), + .prop_entity_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EntityBindPropCsReq = struct { + is_bind: bool = false, + motion: ?MotionInfo = null, + + pub const _desc_table = .{ + .is_bind = fd(5, .{ .Varint = .Simple }), + .motion = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EntityBindPropScRsp = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetClientPausedCsReq = struct { + paused: bool = false, + + pub const _desc_table = .{ + .paused = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetClientPausedScRsp = struct { + paused: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .paused = fd(8, .{ .Varint = .Simple }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AAIPPJOMFHE = struct { + entity_id: u32 = 0, + + pub const _desc_table = .{ + .entity_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ODIOPGHGFPK = struct { + entity_id: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .entity_id = fd(11, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ActivateFarmElementCsReq = struct { + world_level: u32 = 0, + entity_id: u32 = 0, + + pub const _desc_table = .{ + .world_level = fd(13, .{ .Varint = .Simple }), + .entity_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ActivateFarmElementScRsp = struct { + retcode: u32 = 0, + entity_id: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .entity_id = fd(7, .{ .Varint = .Simple }), + .world_level = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AvatarPresetHp = struct { + avatar_id: u32 = 0, + preset_hp: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(5, .{ .Varint = .Simple }), + .preset_hp = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpringRecoverConfig = struct { + avatar_preset_hp_list: ArrayList(AvatarPresetHp), + auto_recover_hp: bool = false, + default_hp: u32 = 0, + + pub const _desc_table = .{ + .avatar_preset_hp_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + .auto_recover_hp = fd(4, .{ .Varint = .Simple }), + .default_hp = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HealPoolInfo = struct { + refresh_time: i64 = 0, + heal_pool: u32 = 0, + + pub const _desc_table = .{ + .refresh_time = fd(11, .{ .Varint = .Simple }), + .heal_pool = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetSpringRecoverDataCsReq = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetSpringRecoverDataScRsp = struct { + retcode: u32 = 0, + heal_pool_info: ?HealPoolInfo = null, + spring_recover_config: ?SpringRecoverConfig = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .heal_pool_info = fd(1, .{ .SubMessage = {} }), + .spring_recover_config = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetSpringRecoverConfigCsReq = struct { + spring_recover_config: ?SpringRecoverConfig = null, + + pub const _desc_table = .{ + .spring_recover_config = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SetSpringRecoverConfigScRsp = struct { + retcode: u32 = 0, + spring_recover_config: ?SpringRecoverConfig = null, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .spring_recover_config = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpringRecoverCsReq = struct { + floor_id: u32 = 0, + plane_id: u32 = 0, + prop_entity_id: u32 = 0, + + pub const _desc_table = .{ + .floor_id = fd(1, .{ .Varint = .Simple }), + .plane_id = fd(4, .{ .Varint = .Simple }), + .prop_entity_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpringRecoverScRsp = struct { + heal_pool_info: ?HealPoolInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .heal_pool_info = fd(4, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HealPoolInfoNotify = struct { + heal_pool_info: ?HealPoolInfo = null, + + pub const _desc_table = .{ + .heal_pool_info = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EPOMDPEBKOG = struct { + plane_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + floor_id: u32 = 0, + id: u32 = 0, + prop_entity_id: u32 = 0, + IECPCPOGIIA: bool = false, + + pub const _desc_table = .{ + .plane_id = fd(7, .{ .Varint = .Simple }), + .avatar_type = fd(10, .{ .Varint = .Simple }), + .floor_id = fd(12, .{ .Varint = .Simple }), + .id = fd(3, .{ .Varint = .Simple }), + .prop_entity_id = fd(13, .{ .Varint = .Simple }), + .IECPCPOGIIA = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SpringRecoverSingleAvatarScRsp = struct { + hp: u32 = 0, + retcode: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + id: u32 = 0, + + pub const _desc_table = .{ + .hp = fd(13, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + .avatar_type = fd(14, .{ .Varint = .Simple }), + .id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBHKFALKHAC = struct { + HJBHLPHBDID: ?ECOEGMPKEFC = null, + floor_id: u32 = 0, + plane_id: u32 = 0, + + pub const _desc_table = .{ + .HJBHLPHBDID = fd(1, .{ .SubMessage = {} }), + .floor_id = fd(14, .{ .Varint = .Simple }), + .plane_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHNDIJKCABM = struct { + BDPJKLJKDDN: ManagedString = .Empty, + entry_id: u32 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .BDPJKLJKDDN = fd(4, .String), + .entry_id = fd(9, .{ .Varint = .Simple }), + .group_id = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOPIMIJOBOA = struct { + retcode: u32 = 0, + entry_id: u32 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .entry_id = fd(7, .{ .Varint = .Simple }), + .group_id = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJLCALAEEBA = struct { + stage_id: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GAKONDHPPMM = struct { + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + stage_id: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(7, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + .stage_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OJGHKBPIJKN = struct { + entry_id: u32 = 0, + LHOBAHBEPDN: ?EntityMotion = null, + + pub const _desc_table = .{ + .entry_id = fd(4, .{ .Varint = .Simple }), + .LHOBAHBEPDN = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILPCHPOENLH = struct { + retcode: u32 = 0, + interact_id: u32 = 0, + LHOBAHBEPDN: ?EntityMotion = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .interact_id = fd(12, .{ .Varint = .Simple }), + .LHOBAHBEPDN = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EDMMIKMDLKI = struct { + entry_id: u32 = 0, + BOCEAHMENHD: u32 = 0, + AABNGFBDJJL: u32 = 0, + GMIGBLFHHAO: u32 = 0, + GHEHAEKNKDP: bool = false, + + pub const _desc_table = .{ + .entry_id = fd(4, .{ .Varint = .Simple }), + .BOCEAHMENHD = fd(3, .{ .Varint = .Simple }), + .AABNGFBDJJL = fd(10, .{ .Varint = .Simple }), + .GMIGBLFHHAO = fd(13, .{ .Varint = .Simple }), + .GHEHAEKNKDP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKPNBCPGHJN = struct { + GMIGBLFHHAO: u32 = 0, + BOCEAHMENHD: u32 = 0, + GHEHAEKNKDP: bool = false, + retcode: u32 = 0, + DPGINBMEPDB: bool = false, + + pub const _desc_table = .{ + .GMIGBLFHHAO = fd(7, .{ .Varint = .Simple }), + .BOCEAHMENHD = fd(8, .{ .Varint = .Simple }), + .GHEHAEKNKDP = fd(9, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + .DPGINBMEPDB = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMONNCPDANB = struct { + NLEFHGHGKPE: EnterSceneReason = @enumFromInt(0), + scene: ?SceneInfo = null, + lineup: ?LineupInfo = null, + + pub const _desc_table = .{ + .NLEFHGHGKPE = fd(1, .{ .Varint = .Simple }), + .scene = fd(10, .{ .SubMessage = {} }), + .lineup = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCONDGFGEBI = struct { + MLIJIGKLDCG: ?ItemList = null, + GHOKFLHACEF: ?ItemList = null, + MFAKDCHPFHC: ?ItemList = null, + NAGPDPMJBKA: ?ItemList = null, + + pub const _desc_table = .{ + .MLIJIGKLDCG = fd(1, .{ .SubMessage = {} }), + .GHOKFLHACEF = fd(6, .{ .SubMessage = {} }), + .MFAKDCHPFHC = fd(12, .{ .SubMessage = {} }), + .NAGPDPMJBKA = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetSceneMapInfoCsReq = struct { + LIAGEOAELCP: u32 = 0, + KOCHBHCMDDO: ArrayList(u32), + GMIGBLFHHAO: u32 = 0, + NKDMCDLKHDK: bool = false, + + pub const _desc_table = .{ + .LIAGEOAELCP = fd(13, .{ .Varint = .Simple }), + .KOCHBHCMDDO = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .GMIGBLFHHAO = fd(2, .{ .Varint = .Simple }), + .NKDMCDLKHDK = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMNCCAPFKLA = struct { + DGFLHAEFBEP: u32 = 0, + group_id: u32 = 0, + state: u32 = 0, + + pub const _desc_table = .{ + .DGFLHAEFBEP = fd(14, .{ .Varint = .Simple }), + .group_id = fd(15, .{ .Varint = .Simple }), + .state = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNOJLEENOBJ = struct { + group_id: u32 = 0, + CEGGNHGFHCG: bool = false, + EFLNADBAABC: ArrayList(u32), + HIKHJIMDJHE: i64 = 0, + + pub const _desc_table = .{ + .group_id = fd(1, .{ .Varint = .Simple }), + .CEGGNHGFHCG = fd(5, .{ .Varint = .Simple }), + .EFLNADBAABC = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + .HIKHJIMDJHE = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IBAECMKPGBC = struct { + GHMDFFAMBPK: u32 = 0, + MJPIKPPJKMF: u32 = 0, + PEIPOPNGOEP: MapInfoChestType = @enumFromInt(0), + + pub const _desc_table = .{ + .GHMDFFAMBPK = fd(7, .{ .Varint = .Simple }), + .MJPIKPPJKMF = fd(3, .{ .Varint = .Simple }), + .PEIPOPNGOEP = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEOBMGCDILL = struct { + EEOLCCFMJFF: u32 = 0, + KIDCFDAHDLP: u32 = 0, + GNJJMDFFOKG: u32 = 0, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(11, .{ .Varint = .Simple }), + .KIDCFDAHDLP = fd(8, .{ .Varint = .Simple }), + .GNJJMDFFOKG = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const SceneMapInfo = struct { + MFLMHFABPJF: ArrayList(MFLMHFABPJFEntry), + CHJJOALILPG: ArrayList(DNOJLEENOBJ), + KLABJGEHJND: ArrayList(NEOBMGCDILL), + retcode: u32 = 0, + GGPGNFLPOKJ: ArrayList(IBAECMKPGBC), + lighten_section_list: ArrayList(u32), + AKAEFHDMPMO: ArrayList(OMNCCAPFKLA), + LCOELBMMICB: u32 = 0, + unlock_teleport_list: ArrayList(u32), + DPIMPNKEOLC: u32 = 0, + GMIGBLFHHAO: u32 = 0, + entry_id: u32 = 0, + LIAGEOAELCP: u32 = 0, + + pub const _desc_table = .{ + .MFLMHFABPJF = fd(12, .{ .List = .{ .SubMessage = {} } }), + .CHJJOALILPG = fd(11, .{ .List = .{ .SubMessage = {} } }), + .KLABJGEHJND = fd(10, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(7, .{ .Varint = .Simple }), + .GGPGNFLPOKJ = fd(3, .{ .List = .{ .SubMessage = {} } }), + .lighten_section_list = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .AKAEFHDMPMO = fd(6, .{ .List = .{ .SubMessage = {} } }), + .LCOELBMMICB = fd(9, .{ .Varint = .Simple }), + .unlock_teleport_list = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .DPIMPNKEOLC = fd(8, .{ .Varint = .Simple }), + .GMIGBLFHHAO = fd(1, .{ .Varint = .Simple }), + .entry_id = fd(4, .{ .Varint = .Simple }), + .LIAGEOAELCP = fd(15, .{ .Varint = .Simple }), + }; + + pub const MFLMHFABPJFEntry = struct { + key: ManagedString = .Empty, + value: i32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetSceneMapInfoScRsp = struct { + retcode: u32 = 0, + NKDMCDLKHDK: bool = false, + map_info_list: ArrayList(SceneMapInfo), + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .NKDMCDLKHDK = fd(5, .{ .Varint = .Simple }), + .map_info_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CJJOIDBPACO = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EJKDFPPPFLG = struct { + KABNOGFDKFI: u32 = 0, + LNDAEICBOPJ: u32 = 0, + + pub const _desc_table = .{ + .KABNOGFDKFI = fd(2, .{ .Varint = .Simple }), + .LNDAEICBOPJ = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const POCJNMLILPN = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OCDPKKBAKDI = struct { + COCFIFOINGL: u32 = 0, + LNDAEICBOPJ: u32 = 0, + NLEFHGHGKPE: GameplayCounterUpdateReason = @enumFromInt(0), + + pub const _desc_table = .{ + .COCFIFOINGL = fd(8, .{ .Varint = .Simple }), + .LNDAEICBOPJ = fd(12, .{ .Varint = .Simple }), + .NLEFHGHGKPE = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCICGDDNHNK = struct { + LNDAEICBOPJ: u32 = 0, + ALEOMEKIPOE: u32 = 0, + + pub const _desc_table = .{ + .LNDAEICBOPJ = fd(13, .{ .Varint = .Simple }), + .ALEOMEKIPOE = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABONDLCKDMO = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFCHMHCHIBA = struct { + DMJOECNDFBO: ArrayList(DMJOECNDFBOEntry), + + pub const _desc_table = .{ + .DMJOECNDFBO = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const DMJOECNDFBOEntry = struct { + key: ManagedString = .Empty, + value: i32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .String), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKGFLNJJNIN = struct { + KOCHBHCMDDO: ArrayList(u32), + + pub const _desc_table = .{ + .KOCHBHCMDDO = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPIBPOECPLH = struct { + unlock_teleport_list: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .unlock_teleport_list = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HFJEMBFAOCL = struct { + IMHANGOPHKG: ?SceneEntityInfo = null, + NPJLKLOKNIK: u32 = 0, + GJLADLHAAMM: u32 = 0, + + pub const _desc_table = .{ + .IMHANGOPHKG = fd(6, .{ .SubMessage = {} }), + .NPJLKLOKNIK = fd(9, .{ .Varint = .Simple }), + .GJLADLHAAMM = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KBCANOCGHGI = struct { + state: u32 = 0, + AKLLBBJIGPL: SceneGroupRefreshType = @enumFromInt(0), + GBGAPGIPHJJ: ArrayList(HFJEMBFAOCL), + group_id: u32 = 0, + + pub const _desc_table = .{ + .state = fd(1, .{ .Varint = .Simple }), + .AKLLBBJIGPL = fd(7, .{ .Varint = .Simple }), + .GBGAPGIPHJJ = fd(5, .{ .List = .{ .SubMessage = {} } }), + .group_id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEPFFJPCNLA = struct { + ADGPDFDBIKN: ArrayList(KBCANOCGHGI), + + pub const _desc_table = .{ + .ADGPDFDBIKN = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FPLBOJJGBHN = struct { + entry_id: u32 = 0, + AEIDKOBLBGL: u32 = 0, + group_id: u32 = 0, + EKAAFFIAFJB: u32 = 0, + + pub const _desc_table = .{ + .entry_id = fd(5, .{ .Varint = .Simple }), + .AEIDKOBLBGL = fd(13, .{ .Varint = .Simple }), + .group_id = fd(8, .{ .Varint = .Simple }), + .EKAAFFIAFJB = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDFODDHDHKF = struct { + JKOCNPOAEEJ: ?FPLBOJJGBHN = null, + + pub const _desc_table = .{ + .JKOCNPOAEEJ = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FDNDGPLBMFG = struct { + JKOCNPOAEEJ: ?FPLBOJJGBHN = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .JKOCNPOAEEJ = fd(3, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HKBKGGIDPCE = struct { + JKOCNPOAEEJ: ?FPLBOJJGBHN = null, + + pub const _desc_table = .{ + .JKOCNPOAEEJ = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HADDAHPDNBE = struct { + plane_id: u32 = 0, + floor_id: u32 = 0, + + pub const _desc_table = .{ + .plane_id = fd(6, .{ .Varint = .Simple }), + .floor_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DEAIGCMAMMG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFMPBAKEDDK = struct { + AAIIAHHDGBL: ArrayList(HADDAHPDNBE), + retcode: u32 = 0, + + pub const _desc_table = .{ + .AAIIAHHDGBL = fd(9, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MIEDNDOHKPD = struct { + AAIIAHHDGBL: ArrayList(HADDAHPDNBE), + + pub const _desc_table = .{ + .AAIIAHHDGBL = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFNPKHOOPIK = struct { + CNEBNONPIJI: ArrayList(u32), + OCILPPELKJD: ?MotionInfo = null, + JLMJKAGHNNC: u32 = 0, + OGIKMIFLCFG: ManagedString = .Empty, + + pub const _desc_table = .{ + .CNEBNONPIJI = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .OCILPPELKJD = fd(5, .{ .SubMessage = {} }), + .JLMJKAGHNNC = fd(4, .{ .Varint = .Simple }), + .OGIKMIFLCFG = fd(10, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MECFIFLCPFC = struct { + EODHNEKLADA: bool = false, + retcode: u32 = 0, + OGIKMIFLCFG: ManagedString = .Empty, + JLMJKAGHNNC: u32 = 0, + + pub const _desc_table = .{ + .EODHNEKLADA = fd(2, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + .OGIKMIFLCFG = fd(13, .String), + .JLMJKAGHNNC = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLMEJFDPDMO = struct { + JLMJKAGHNNC: u32 = 0, + OGIKMIFLCFG: ManagedString = .Empty, + CNEBNONPIJI: ArrayList(u32), + + pub const _desc_table = .{ + .JLMJKAGHNNC = fd(13, .{ .Varint = .Simple }), + .OGIKMIFLCFG = fd(11, .String), + .CNEBNONPIJI = fd(12, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKNBIDKFIME = struct { + OLNOHBLOFPM: ArrayList(u32), + + pub const _desc_table = .{ + .OLNOHBLOFPM = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJFCJGBAAFA = struct { + OLNOHBLOFPM: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .OLNOHBLOFPM = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const COKOEKPFPKD = struct { + KOCHBHCMDDO: ArrayList(u32), + + pub const _desc_table = .{ + .KOCHBHCMDDO = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECAIDBMNJFA = struct { + world_level: u32 = 0, + cocoon_id: u32 = 0, + wave: u32 = 0, + + pub const _desc_table = .{ + .world_level = fd(2, .{ .Varint = .Simple }), + .cocoon_id = fd(3, .{ .Varint = .Simple }), + .wave = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FBFBLNDBEMK = struct { + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + wave: u32 = 0, + cocoon_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .battle_info = fd(7, .{ .SubMessage = {} }), + .wave = fd(1, .{ .Varint = .Simple }), + .cocoon_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGJHEEPAEIE = struct { + PHEEKFOCBJJ: u32 = 0, + world_level: u32 = 0, + + pub const _desc_table = .{ + .PHEEKFOCBJJ = fd(10, .{ .Varint = .Simple }), + .world_level = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCJMKHAJHNB = struct { + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + world_level: u32 = 0, + PHEEKFOCBJJ: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(5, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + .world_level = fd(4, .{ .Varint = .Simple }), + .PHEEKFOCBJJ = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GBFNBGEJBIM = struct { + entry_id: u32 = 0, + AABNGFBDJJL: u32 = 0, + + pub const _desc_table = .{ + .entry_id = fd(5, .{ .Varint = .Simple }), + .AABNGFBDJJL = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGNCPHNJLLC = struct { + data: ManagedString = .Empty, + DPPOPLIPLMH: u32 = 0, + + pub const _desc_table = .{ + .data = fd(15, .String), + .DPPOPLIPLMH = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKODDAEGKPB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FHPLIOGIGIN = struct { + retcode: u32 = 0, + CFHMFEBMJIK: ArrayList(DGNCPHNJLLC), + + pub const _desc_table = .{ + .retcode = fd(11, .{ .Varint = .Simple }), + .CFHMFEBMJIK = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMDEDJKFJCA = struct { + DPPOPLIPLMH: u32 = 0, + + pub const _desc_table = .{ + .DPPOPLIPLMH = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEHCJENAKEA = struct { + retcode: u32 = 0, + BBLAPPLLMBO: ?DGNCPHNJLLC = null, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .BBLAPPLLMBO = fd(7, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAMDJHLCHKA = struct { + BBLAPPLLMBO: ?DGNCPHNJLLC = null, + + pub const _desc_table = .{ + .BBLAPPLLMBO = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHOIFBBOGJK = struct { + retcode: u32 = 0, + DPPOPLIPLMH: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .DPPOPLIPLMH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Shop = struct { + goods_list: ArrayList(Goods), + city_level: u32 = 0, + city_taken_level_reward: u64 = 0, + shop_id: u32 = 0, + begin_time: i64 = 0, + end_time: i64 = 0, + city_exp: u32 = 0, + + pub const _desc_table = .{ + .goods_list = fd(8, .{ .List = .{ .SubMessage = {} } }), + .city_level = fd(5, .{ .Varint = .Simple }), + .city_taken_level_reward = fd(2, .{ .Varint = .Simple }), + .shop_id = fd(14, .{ .Varint = .Simple }), + .begin_time = fd(6, .{ .Varint = .Simple }), + .end_time = fd(15, .{ .Varint = .Simple }), + .city_exp = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Goods = struct { + buy_times: u32 = 0, + goods_id: u32 = 0, + begin_time: i64 = 0, + item_id: u32 = 0, + end_time: i64 = 0, + + pub const _desc_table = .{ + .buy_times = fd(6, .{ .Varint = .Simple }), + .goods_id = fd(8, .{ .Varint = .Simple }), + .begin_time = fd(11, .{ .Varint = .Simple }), + .item_id = fd(9, .{ .Varint = .Simple }), + .end_time = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGJCGLKDHOA = struct { + NAHKEGDMPOH: u32 = 0, + + pub const _desc_table = .{ + .NAHKEGDMPOH = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetShopListScRsp = struct { + retcode: u32 = 0, + shop_type: u32 = 0, + shop_list: ArrayList(Shop), + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .shop_type = fd(11, .{ .Varint = .Simple }), + .shop_list = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNNPHGFMDLB = struct { + ICAABODNFIC: u32 = 0, + OJCFOBHCBHK: u32 = 0, + AALFIHNDABH: u32 = 0, + GBIEPAPENKJ: u32 = 0, + LDOLLOOEIKA: u32 = 0, + + pub const _desc_table = .{ + .ICAABODNFIC = fd(9, .{ .Varint = .Simple }), + .OJCFOBHCBHK = fd(13, .{ .Varint = .Simple }), + .AALFIHNDABH = fd(5, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(4, .{ .Varint = .Simple }), + .LDOLLOOEIKA = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BuyGoodsScRsp = struct { + shop_id: u32 = 0, + return_item_list: ?ItemList = null, + goods_buy_times: u32 = 0, + retcode: u32 = 0, + goods_id: u32 = 0, + + pub const _desc_table = .{ + .shop_id = fd(2, .{ .Varint = .Simple }), + .return_item_list = fd(7, .{ .SubMessage = {} }), + .goods_buy_times = fd(8, .{ .Varint = .Simple }), + .retcode = fd(14, .{ .Varint = .Simple }), + .goods_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BPPHJHIBBJO = struct { + OJCFOBHCBHK: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .OJCFOBHCBHK = fd(2, .{ .Varint = .Simple }), + .level = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const TakeCityShopRewardScRsp = struct { + level: u32 = 0, + retcode: u32 = 0, + reward: ?ItemList = null, + shop_id: u32 = 0, + + pub const _desc_table = .{ + .level = fd(9, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + .reward = fd(11, .{ .SubMessage = {} }), + .shop_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CityShopInfoScNotify = struct { + shop_id: u32 = 0, + taken_level_reward: u64 = 0, + level: u32 = 0, + exp: u32 = 0, + + pub const _desc_table = .{ + .shop_id = fd(14, .{ .Varint = .Simple }), + .taken_level_reward = fd(13, .{ .Varint = .Simple }), + .level = fd(15, .{ .Varint = .Simple }), + .exp = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMEDPBBAOHC = struct { + LHFFLOKIELE: ArrayList(u32), + CPHKOCPKCOI: bool = false, + unique_id: u32 = 0, + LLJJPOFJNKK: ArrayList(u32), + EFICNPDCKPK: u32 = 0, + GJIOOFGKPJC: u32 = 0, + + pub const _desc_table = .{ + .LHFFLOKIELE = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + .CPHKOCPKCOI = fd(15, .{ .Varint = .Simple }), + .unique_id = fd(5, .{ .Varint = .Simple }), + .LLJJPOFJNKK = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .EFICNPDCKPK = fd(4, .{ .Varint = .Simple }), + .GJIOOFGKPJC = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOHKNIOIIGC = struct { + GJIOOFGKPJC: u32 = 0, + CJJFDEEODJJ: u32 = 0, + + pub const _desc_table = .{ + .GJIOOFGKPJC = fd(11, .{ .Varint = .Simple }), + .CJJFDEEODJJ = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HKCGCEEHEKC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJOMPPNMIML = struct { + FDDJIGPNEJM: ArrayList(u32), + PGKBEAAGNLE: u32 = 0, + retcode: u32 = 0, + BJENPIIBHKB: ArrayList(KMEDPBBAOHC), + LDNEMBBHPIE: ArrayList(u32), + OFKELCHFKEO: ArrayList(u32), + IHNAFHDGGAO: ArrayList(OOHKNIOIIGC), + LKGBPNPNILM: ArrayList(u32), + CENFNPDHBIJ: ArrayList(u32), + + pub const _desc_table = .{ + .FDDJIGPNEJM = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .PGKBEAAGNLE = fd(12, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .BJENPIIBHKB = fd(7, .{ .List = .{ .SubMessage = {} } }), + .LDNEMBBHPIE = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .OFKELCHFKEO = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .IHNAFHDGGAO = fd(3, .{ .List = .{ .SubMessage = {} } }), + .LKGBPNPNILM = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .CENFNPDHBIJ = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEBKILGJNOB = struct { + GBBLMJHMBFA: u32 = 0, + CHLDHCPCPDE: ArrayList(u32), + + pub const _desc_table = .{ + .GBBLMJHMBFA = fd(8, .{ .Varint = .Simple }), + .CHLDHCPCPDE = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AOLFNJJOHBF = struct { + BPEGLOJENEN: ?KMEDPBBAOHC = null, + NNICHBFOECC: ArrayList(OOHKNIOIIGC), + LOJOEDFDIEE: bool = false, + retcode: u32 = 0, + + pub const _desc_table = .{ + .BPEGLOJENEN = fd(8, .{ .SubMessage = {} }), + .NNICHBFOECC = fd(13, .{ .List = .{ .SubMessage = {} } }), + .LOJOEDFDIEE = fd(12, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMLECKAJCAO = struct { + unique_id: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .unique_id = fd(5, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGBDPCKHMHH = struct { + EJAHFAMAGIE: ?KMEDPBBAOHC = null, + retcode: u32 = 0, + LOJOEDFDIEE: bool = false, + NNICHBFOECC: ArrayList(OOHKNIOIIGC), + + pub const _desc_table = .{ + .EJAHFAMAGIE = fd(2, .{ .SubMessage = {} }), + .retcode = fd(10, .{ .Varint = .Simple }), + .LOJOEDFDIEE = fd(6, .{ .Varint = .Simple }), + .NNICHBFOECC = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLKCGADNCHH = struct { + op_type: u32 = 0, + HEJAFGLNFFP: u32 = 0, + FAOILJIEDHF: u32 = 0, + + pub const _desc_table = .{ + .op_type = fd(13, .{ .Varint = .Simple }), + .HEJAFGLNFFP = fd(6, .{ .Varint = .Simple }), + .FAOILJIEDHF = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LMELGKMIPOH = struct { + retcode: u32 = 0, + FDDJIGPNEJM: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .FDDJIGPNEJM = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBDBMKCEGFO = struct { + NLFHLICKMNB: ArrayList(u32), + + pub const _desc_table = .{ + .NLFHLICKMNB = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BMDHAKDAHAN = struct { + OGAENMPEINB: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .OGAENMPEINB = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLAOCMDEBOG = struct { + HLNKBDEDNAM: ArrayList(KMEDPBBAOHC), + HJMBAIIMKMH: bool = false, + LOJOEDFDIEE: bool = false, + + pub const _desc_table = .{ + .HLNKBDEDNAM = fd(1, .{ .List = .{ .SubMessage = {} } }), + .HJMBAIIMKMH = fd(10, .{ .Varint = .Simple }), + .LOJOEDFDIEE = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JBDECLMLHEG = struct { + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CFGPADBFEDO = struct { + GBIEPAPENKJ: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(14, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CKLIOGJFKMF = struct { + MCALJKBGIOI: u32 = 0, + + pub const _desc_table = .{ + .MCALJKBGIOI = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AAAHMBHKLPO = struct { + retcode: u32 = 0, + MCALJKBGIOI: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .MCALJKBGIOI = fd(2, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GMFILGICFFC = struct { + OLCPIFJCBFP: u32 = 0, + KNCCCCGBPED: bool = false, + group_id: u32 = 0, + INEMBEBIPAN: u32 = 0, + AHLOGIGDNLF: u32 = 0, + + pub const _desc_table = .{ + .OLCPIFJCBFP = fd(9, .{ .Varint = .Simple }), + .KNCCCCGBPED = fd(2, .{ .Varint = .Simple }), + .group_id = fd(3, .{ .Varint = .Simple }), + .INEMBEBIPAN = fd(14, .{ .Varint = .Simple }), + .AHLOGIGDNLF = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJIKCBAEIBN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IPJFIHMHMJB = struct { + retcode: u32 = 0, + DHJIDDDCPPB: ArrayList(GMFILGICFFC), + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .DHJIDDDCPPB = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHDGMDLCNLL = struct { + avatar_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(5, .{ .Varint = .Simple }), + .avatar_type = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LJNLHMBAMPJ = struct { + IHKPKPJKKBI: u32 = 0, + group_id: u32 = 0, + avatar_list: ArrayList(OHDGMDLCNLL), + + pub const _desc_table = .{ + .IHKPKPJKKBI = fd(11, .{ .Varint = .Simple }), + .group_id = fd(7, .{ .Varint = .Simple }), + .avatar_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JLPLDBOHNOK = struct { + retcode: u32 = 0, + IHKPKPJKKBI: u32 = 0, + group_id: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .IHKPKPJKKBI = fd(7, .{ .Varint = .Simple }), + .group_id = fd(14, .{ .Varint = .Simple }), + .battle_info = fd(6, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BHGMHDJCLCG = struct { + group_id: u32 = 0, + NBCHIGBIADL: ?GMFILGICFFC = null, + + pub const _desc_table = .{ + .group_id = fd(15, .{ .Varint = .Simple }), + .NBCHIGBIADL = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DHOCLNODGCF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CMNEJHMIINN = struct { + HANFDCIPMMD: ArrayList(u32), + retcode: u32 = 0, + GBPFEGKAJAG: u32 = 0, + EPOFFJINPJJ: ArrayList(u32), + + pub const _desc_table = .{ + .HANFDCIPMMD = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(6, .{ .Varint = .Simple }), + .GBPFEGKAJAG = fd(13, .{ .Varint = .Simple }), + .EPOFFJINPJJ = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ADENECOIBMH = struct { + GBPFEGKAJAG: u32 = 0, + HANFDCIPMMD: ArrayList(u32), + EPOFFJINPJJ: ArrayList(u32), + + pub const _desc_table = .{ + .GBPFEGKAJAG = fd(3, .{ .Varint = .Simple }), + .HANFDCIPMMD = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .EPOFFJINPJJ = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIIOFAPEDKH = struct { + BKFEJKEEAHP: u32 = 0, + GBPFEGKAJAG: u32 = 0, + DFOLOHBFFJJ: EJJDPOJOLMG = @enumFromInt(0), + + pub const _desc_table = .{ + .BKFEJKEEAHP = fd(5, .{ .Varint = .Simple }), + .GBPFEGKAJAG = fd(12, .{ .Varint = .Simple }), + .DFOLOHBFFJJ = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BIGFGJHAHEL = struct { + NGGDMOLENLB: ArrayList(u32), + PJELGNOFHEC: ArrayList(u32), + + pub const _desc_table = .{ + .NGGDMOLENLB = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .PJELGNOFHEC = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const StrongChallengeAvatar = struct { + avatar_type: AvatarType = @enumFromInt(0), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(10, .{ .Varint = .Simple }), + .avatar_id = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFPNFBLIHDC = struct { + avatar_list: ArrayList(StrongChallengeAvatar), + buff_list: ArrayList(u32), + + pub const _desc_table = .{ + .avatar_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJMLLGKLNMF = struct { + GPEDJAGNFHI: ?EFPNFBLIHDC = null, + stage_id: u32 = 0, + ABEDIGLKNCF: u32 = 0, + EDNOBGJCMBK: u32 = 0, + FOGBECBDFDM: u32 = 0, + + pub const _desc_table = .{ + .GPEDJAGNFHI = fd(10, .{ .SubMessage = {} }), + .stage_id = fd(12, .{ .Varint = .Simple }), + .ABEDIGLKNCF = fd(3, .{ .Varint = .Simple }), + .EDNOBGJCMBK = fd(2, .{ .Varint = .Simple }), + .FOGBECBDFDM = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELMKJKBEDCC = struct { + GOOJLHGGPCP: ArrayList(GOOJLHGGPCPEntry), + + pub const _desc_table = .{ + .GOOJLHGGPCP = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const GOOJLHGGPCPEntry = struct { + key: u32 = 0, + value: ?AJMLLGKLNMF = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOFHHINNNNJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MCBIHCPGDGG = struct { + EFJAMCICBEN: ?ELMKJKBEDCC = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .EFJAMCICBEN = fd(9, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBBJMJHMOHC = struct { + avatar_list: ArrayList(StrongChallengeAvatar), + buff_list: ArrayList(u32), + stage_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_list = fd(4, .{ .List = .{ .SubMessage = {} } }), + .buff_list = fd(15, .{ .PackedList = .{ .Varint = .Simple } }), + .stage_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LOHFFEGANBP = struct { + retcode: u32 = 0, + stage_id: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .stage_id = fd(11, .{ .Varint = .Simple }), + .battle_info = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLOOADFLAIO = struct { + FOGBECBDFDM: u32 = 0, + stage_id: u32 = 0, + FDDOLEGBPHH: u32 = 0, + HNJKNJNNDPJ: u32 = 0, + LMEDPAKEJCK: u32 = 0, + end_status: BattleEndStatus = @enumFromInt(0), + total_damage: u32 = 0, + KOIEIBKKMJF: u32 = 0, + + pub const _desc_table = .{ + .FOGBECBDFDM = fd(5, .{ .Varint = .Simple }), + .stage_id = fd(14, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(7, .{ .Varint = .Simple }), + .HNJKNJNNDPJ = fd(13, .{ .Varint = .Simple }), + .LMEDPAKEJCK = fd(6, .{ .Varint = .Simple }), + .end_status = fd(8, .{ .Varint = .Simple }), + .total_damage = fd(11, .{ .Varint = .Simple }), + .KOIEIBKKMJF = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LKIFECIINFP = struct { + HEMJIDNEAHO: u32 = 0, + group_id: u32 = 0, + IHKPKPJKKBI: u32 = 0, + + pub const _desc_table = .{ + .HEMJIDNEAHO = fd(1, .{ .Varint = .Simple }), + .group_id = fd(7, .{ .Varint = .Simple }), + .IHKPKPJKKBI = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FDIMLAGNCKI = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHKCKPBGJCC = struct { + ADNEOCNPOLI: ArrayList(LKIFECIINFP), + retcode: u32 = 0, + + pub const _desc_table = .{ + .ADNEOCNPOLI = fd(10, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLDFNPEJFHK = struct { + avatar_type: AvatarType = @enumFromInt(0), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(14, .{ .Varint = .Simple }), + .avatar_id = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LALFLDBJECG = struct { + avatar_list: ArrayList(DLDFNPEJFHK), + group_id: u32 = 0, + NGMJLMPBIBK: ?DLDFNPEJFHK = null, + IHKPKPJKKBI: u32 = 0, + + pub const _desc_table = .{ + .avatar_list = fd(5, .{ .List = .{ .SubMessage = {} } }), + .group_id = fd(2, .{ .Varint = .Simple }), + .NGMJLMPBIBK = fd(15, .{ .SubMessage = {} }), + .IHKPKPJKKBI = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PLNBFPKJFJI = struct { + battle_info: ?SceneBattleInfo = null, + group_id: u32 = 0, + retcode: u32 = 0, + IHKPKPJKKBI: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(8, .{ .SubMessage = {} }), + .group_id = fd(6, .{ .Varint = .Simple }), + .retcode = fd(13, .{ .Varint = .Simple }), + .IHKPKPJKKBI = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOGOBCKPIAC = struct { + HEMJIDNEAHO: u32 = 0, + EECDAKBHKMK: u32 = 0, + IHKPKPJKKBI: u32 = 0, + group_id: u32 = 0, + + pub const _desc_table = .{ + .HEMJIDNEAHO = fd(1, .{ .Varint = .Simple }), + .EECDAKBHKMK = fd(2, .{ .Varint = .Simple }), + .IHKPKPJKKBI = fd(7, .{ .Varint = .Simple }), + .group_id = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GDGGKONPNIG = struct { + OHLDFLFFDAA: ?AEOPGHJKBIB = null, + MCKIEJODKGE: ?ECIGNEGEAIH = null, + HOFHOOKIBOE: ?DCAIJIDBGBK = null, + IIHDBEFHEOC: ?KCFNOAMOLFC = null, + INJNGCMDBGL: ?KKIPILADIGB = null, + FENFEHFCGPO: ?KKDCJKFPLMF = null, + MGKDFNBENAI: u32 = 0, + BNKLPFGAGPE: ArrayList(DLBAMGFIACN), + DPHNBKLJEHM: ArrayList(u32), + ALPKEBCOOFG: ?HAACPPDHENG = null, + + pub const _desc_table = .{ + .OHLDFLFFDAA = fd(15, .{ .SubMessage = {} }), + .MCKIEJODKGE = fd(3, .{ .SubMessage = {} }), + .HOFHOOKIBOE = fd(12, .{ .SubMessage = {} }), + .IIHDBEFHEOC = fd(14, .{ .SubMessage = {} }), + .INJNGCMDBGL = fd(2, .{ .SubMessage = {} }), + .FENFEHFCGPO = fd(1, .{ .SubMessage = {} }), + .MGKDFNBENAI = fd(5, .{ .Varint = .Simple }), + .BNKLPFGAGPE = fd(8, .{ .List = .{ .SubMessage = {} } }), + .DPHNBKLJEHM = fd(6, .{ .PackedList = .{ .Varint = .Simple } }), + .ALPKEBCOOFG = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PNOMCOHCMLF = struct { + EEOLCCFMJFF: u32 = 0, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IKLLALNCCMD = struct { + EEOLCCFMJFF: u32 = 0, + retcode: u32 = 0, + NHPHHAPJODG: ArrayList(u32), + FEKILLBIEKO: ArrayList(u32), + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(2, .{ .Varint = .Simple }), + .retcode = fd(15, .{ .Varint = .Simple }), + .NHPHHAPJODG = fd(7, .{ .PackedList = .{ .Varint = .Simple } }), + .FEKILLBIEKO = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLBAMGFIACN = struct { + NBHPDMDNDKL: u32 = 0, + DGFLHAEFBEP: u32 = 0, + + pub const _desc_table = .{ + .NBHPDMDNDKL = fd(9, .{ .Varint = .Simple }), + .DGFLHAEFBEP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AEOPGHJKBIB = struct { + OAJMNPADHGA: u32 = 0, + PAOJAAONCBF: u32 = 0, + BCMNPJJHJAD: u32 = 0, + FEKILLBIEKO: ArrayList(u32), + + pub const _desc_table = .{ + .OAJMNPADHGA = fd(14, .{ .Varint = .Simple }), + .PAOJAAONCBF = fd(7, .{ .Varint = .Simple }), + .BCMNPJJHJAD = fd(1, .{ .Varint = .Simple }), + .FEKILLBIEKO = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLHGCNIAGLC = struct { + BHEFFIAOLJB: u32 = 0, + LJHKGLDHNIO: u32 = 0, + + pub const _desc_table = .{ + .BHEFFIAOLJB = fd(6, .{ .Varint = .Simple }), + .LJHKGLDHNIO = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCFNOAMOLFC = struct { + MFOIJABLHJO: ArrayList(LLHGCNIAGLC), + + pub const _desc_table = .{ + .MFOIJABLHJO = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECIGNEGEAIH = struct { + BOCEAHMENHD: u32 = 0, + JAFLOLLFNDO: u32 = 0, + MOOHNCHOPNH: ArrayList(u32), + HCMJKFEAADP: ArrayList(u32), + + pub const _desc_table = .{ + .BOCEAHMENHD = fd(7, .{ .Varint = .Simple }), + .JAFLOLLFNDO = fd(6, .{ .Varint = .Simple }), + .MOOHNCHOPNH = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .HCMJKFEAADP = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDHLJLCFKMO = struct { + value: u32 = 0, + PCLPEHLNDAF: u32 = 0, + AIKKMCBGKOM: FDFBKCOHBJG = @enumFromInt(0), + + pub const _desc_table = .{ + .value = fd(10, .{ .Varint = .Simple }), + .PCLPEHLNDAF = fd(4, .{ .Varint = .Simple }), + .AIKKMCBGKOM = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCAIJIDBGBK = struct { + AOMADOAGOCG: u32 = 0, + NGKPHAFHJGP: ArrayList(JDHLJLCFKMO), + NGJMHNPDPLH: u32 = 0, + + pub const _desc_table = .{ + .AOMADOAGOCG = fd(6, .{ .Varint = .Simple }), + .NGKPHAFHJGP = fd(14, .{ .List = .{ .SubMessage = {} } }), + .NGJMHNPDPLH = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOGAHFDMHJM = struct { + NGKPHAFHJGP: ArrayList(JDHLJLCFKMO), + + pub const _desc_table = .{ + .NGKPHAFHJGP = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDIOIIGICIF = struct { + KDDFCIJKDKK: u32 = 0, + level: u32 = 0, + + pub const _desc_table = .{ + .KDDFCIJKDKK = fd(6, .{ .Varint = .Simple }), + .level = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HAACPPDHENG = struct { + NLGPPPBJBLL: ArrayList(JDIOIIGICIF), + + pub const _desc_table = .{ + .NLGPPPBJBLL = fd(2, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKIPILADIGB = struct { + MIMOGGLAFID: u32 = 0, + PAOKBIDANEJ: ?MHBCFFNEBEL = null, + MMAKPNLBHII: ?EKEMGBNIACI = null, + + pub const _desc_table = .{ + .MIMOGGLAFID = fd(632, .{ .Varint = .Simple }), + .PAOKBIDANEJ = fd(14, .{ .SubMessage = {} }), + .MMAKPNLBHII = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDNNEFNIEGL = struct { + ADENLFJOOPL: u32 = 0, + PBNBFPABMFP: u32 = 0, + MCKOMCKFKLG: u32 = 0, + + pub const _desc_table = .{ + .ADENLFJOOPL = fd(12, .{ .Varint = .Simple }), + .PBNBFPABMFP = fd(8, .{ .Varint = .Simple }), + .MCKOMCKFKLG = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MHBCFFNEBEL = struct { + JHINDCDBNML: ArrayList(u32), + GPJGAFFCMNG: JECNAADIEAE = @enumFromInt(0), + LOJFKFFCEAA: ArrayList(JDNNEFNIEGL), + + pub const _desc_table = .{ + .JHINDCDBNML = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .GPJGAFFCMNG = fd(11, .{ .Varint = .Simple }), + .LOJFKFFCEAA = fd(10, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EKEMGBNIACI = struct { + NONMKEIGEGF: u32 = 0, + + pub const _desc_table = .{ + .NONMKEIGEGF = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KKDCJKFPLMF = struct { + PCPAFLJBGDD: ?PKGODKBNAAM = null, + LGBCIKNKPOK: ?NJAHHFGIMBF = null, + JAHPBDGDIGN: ?NGFELCGLDGB = null, + OLNKGJDOECP: ?OALMPFHPFPK = null, + DAIBJMDJPKJ: ?OEJIIDGGGBO = null, + AOPBDFIBFPH: ?BOIFCPNAOLC = null, + AEPOACPOGND: ?LFNDEHMBKNN = null, + AFGIMCBOJFL: ?ENGJLGMAOAC = null, + + pub const _desc_table = .{ + .PCPAFLJBGDD = fd(2, .{ .SubMessage = {} }), + .LGBCIKNKPOK = fd(3, .{ .SubMessage = {} }), + .JAHPBDGDIGN = fd(9, .{ .SubMessage = {} }), + .OLNKGJDOECP = fd(14, .{ .SubMessage = {} }), + .DAIBJMDJPKJ = fd(5, .{ .SubMessage = {} }), + .AOPBDFIBFPH = fd(4, .{ .SubMessage = {} }), + .AEPOACPOGND = fd(7, .{ .SubMessage = {} }), + .AFGIMCBOJFL = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PKGODKBNAAM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NJAHHFGIMBF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NGFELCGLDGB = struct { + IAGJGJKGJBL: u32 = 0, + + pub const _desc_table = .{ + .IAGJGJKGJBL = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OALMPFHPFPK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OEJIIDGGGBO = struct { + LHMPHPEODNP: u32 = 0, + NBBEBBCAKBE: bool = false, + + pub const _desc_table = .{ + .LHMPHPEODNP = fd(4, .{ .Varint = .Simple }), + .NBBEBBCAKBE = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOIFCPNAOLC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LFNDEHMBKNN = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENGJLGMAOAC = struct { + LHMPHPEODNP: u32 = 0, + MIIDPLKIHDA: bool = false, + + pub const _desc_table = .{ + .LHMPHPEODNP = fd(5, .{ .Varint = .Simple }), + .MIIDPLKIHDA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFDCFCKHILP = struct { + EOLEGGEPOIO: ?HNADJAAFBMJ = null, + LGEKDBJJLNI: IMPNHHHPMBA = @enumFromInt(0), + + pub const _desc_table = .{ + .EOLEGGEPOIO = fd(1, .{ .SubMessage = {} }), + .LGEKDBJJLNI = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNADJAAFBMJ = struct { + PEIIECHJBOH: ?EJNNNBLNJIC = null, + LLBPGOIFDAD: ?HOFBPPLLJGJ = null, + ILBOHKPGEBN: ?HOFBPPLLJGJ = null, + BJLIOIKGPCK: ?ANDOCAGGDMH = null, + BHCEKMIEFKC: ?ANDOCAGGDMH = null, + INMOIILMOJN: ?EFLKKNBMPHB = null, + LDMGDOGJKNC: ?HNHNFFFGFJC = null, + NOJFNAKKOJO: ?OEJIIDGGGBO = null, + DOBMEMOFBDE: ?DLBAMGFIACN = null, + FHFOFHBEIGI: ?DLBAMGFIACN = null, + KABMHIGOCHM: ?LCEMAIAAPCA = null, + DMOGPPBEFNA: u32 = 0, + NGJMHNPDPLH: u32 = 0, + IFBIMMDFOED: ?OOGAHFDMHJM = null, + KENCPJJECKL: ?ENGJLGMAOAC = null, + NHNNHJBBGAB: ?BOIFCPNAOLC = null, + + pub const _desc_table = .{ + .PEIIECHJBOH = fd(3, .{ .SubMessage = {} }), + .LLBPGOIFDAD = fd(8, .{ .SubMessage = {} }), + .ILBOHKPGEBN = fd(15, .{ .SubMessage = {} }), + .BJLIOIKGPCK = fd(14, .{ .SubMessage = {} }), + .BHCEKMIEFKC = fd(2, .{ .SubMessage = {} }), + .INMOIILMOJN = fd(5, .{ .SubMessage = {} }), + .LDMGDOGJKNC = fd(11, .{ .SubMessage = {} }), + .NOJFNAKKOJO = fd(10, .{ .SubMessage = {} }), + .DOBMEMOFBDE = fd(12, .{ .SubMessage = {} }), + .FHFOFHBEIGI = fd(9, .{ .SubMessage = {} }), + .KABMHIGOCHM = fd(1, .{ .SubMessage = {} }), + .DMOGPPBEFNA = fd(7, .{ .Varint = .Simple }), + .NGJMHNPDPLH = fd(623, .{ .Varint = .Simple }), + .IFBIMMDFOED = fd(1133, .{ .SubMessage = {} }), + .KENCPJJECKL = fd(343, .{ .SubMessage = {} }), + .NHNNHJBBGAB = fd(747, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LCEMAIAAPCA = struct { + IAGJGJKGJBL: u32 = 0, + + pub const _desc_table = .{ + .IAGJGJKGJBL = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EJNNNBLNJIC = struct { + AIKKMCBGKOM: FDFBKCOHBJG = @enumFromInt(0), + ILGEENMAONM: u32 = 0, + PJHIPNNJDDP: u32 = 0, + + pub const _desc_table = .{ + .AIKKMCBGKOM = fd(15, .{ .Varint = .Simple }), + .ILGEENMAONM = fd(11, .{ .Varint = .Simple }), + .PJHIPNNJDDP = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HOFBPPLLJGJ = struct { + PJHIPNNJDDP: u32 = 0, + ILGEENMAONM: u32 = 0, + + pub const _desc_table = .{ + .PJHIPNNJDDP = fd(2, .{ .Varint = .Simple }), + .ILGEENMAONM = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANDOCAGGDMH = struct { + ILGEENMAONM: u32 = 0, + PJHIPNNJDDP: u32 = 0, + + pub const _desc_table = .{ + .ILGEENMAONM = fd(2, .{ .Varint = .Simple }), + .PJHIPNNJDDP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFLKKNBMPHB = struct { + level: u32 = 0, + KDDFCIJKDKK: u32 = 0, + AKDDEGHFEGG: u32 = 0, + + pub const _desc_table = .{ + .level = fd(15, .{ .Varint = .Simple }), + .KDDFCIJKDKK = fd(11, .{ .Varint = .Simple }), + .AKDDEGHFEGG = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNHNFFFGFJC = struct { + MGKDFNBENAI: u32 = 0, + PCMAAKHAEBC: ?KKIPILADIGB = null, + + pub const _desc_table = .{ + .MGKDFNBENAI = fd(10, .{ .Varint = .Simple }), + .PCMAAKHAEBC = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BECAJOBHPIP = struct { + LHMPHPEODNP: u32 = 0, + NBBEBBCAKBE: bool = false, + + pub const _desc_table = .{ + .LHMPHPEODNP = fd(14, .{ .Varint = .Simple }), + .NBBEBBCAKBE = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BFGHEKNAALJ = struct { + IPHCFMPAMNF: ArrayList(BFDCFCKHILP), + + pub const _desc_table = .{ + .IPHCFMPAMNF = fd(5, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNLEFEGOBEG = struct { + progress: u32 = 0, + id: u32 = 0, + + pub const _desc_table = .{ + .progress = fd(7, .{ .Varint = .Simple }), + .id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KOBFGKFDMJE = struct { + FGCDDCJHIAG: ArrayList(u32), + AKPGGHKCAIF: ArrayList(DNLEFEGOBEG), + + pub const _desc_table = .{ + .FGCDDCJHIAG = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .AKPGGHKCAIF = fd(11, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHKMAPGJHED = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KDONKLNAICI = struct { + MOOHNCHOPNH: ArrayList(u32), + DAPAKMMMAOJ: ?GDGGKONPNIG = null, + AILAGENLDGI: u32 = 0, + DIGIDEKCKPF: ArrayList(u32), + retcode: u32 = 0, + IMJLPHEJMBB: ?KOBFGKFDMJE = null, + DPHNBKLJEHM: ArrayList(u32), + BNNIMFGFOAH: ArrayList(u32), + GBDANLKCLMG: ArrayList(u32), + + pub const _desc_table = .{ + .MOOHNCHOPNH = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + .DAPAKMMMAOJ = fd(11, .{ .SubMessage = {} }), + .AILAGENLDGI = fd(8, .{ .Varint = .Simple }), + .DIGIDEKCKPF = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(12, .{ .Varint = .Simple }), + .IMJLPHEJMBB = fd(7, .{ .SubMessage = {} }), + .DPHNBKLJEHM = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .BNNIMFGFOAH = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .GBDANLKCLMG = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IOMJGKBIAFK = struct { + ECFPHAADBDI: ArrayList(u32), + AOBGMOJOFLP: ArrayList(u32), + + pub const _desc_table = .{ + .ECFPHAADBDI = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .AOBGMOJOFLP = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IGBCHKMINLM = struct { + AOBGMOJOFLP: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .AOBGMOJOFLP = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LANKBIELLHP = struct { + ADENLFJOOPL: u32 = 0, + + pub const _desc_table = .{ + .ADENLFJOOPL = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EACNAKCAJHP = struct { + retcode: u32 = 0, + DBJOEONEGCE: ?JDNNEFNIEGL = null, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .DBJOEONEGCE = fd(13, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JJLLFHOLLGC = struct { + MDPMCJGPIIO: JECNAADIEAE = @enumFromInt(0), + + pub const _desc_table = .{ + .MDPMCJGPIIO = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELKMCNJBFAD = struct { + retcode: u32 = 0, + BPMPJHFFELH: bool = false, + DCECFOKFIHH: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .BPMPJHFFELH = fd(15, .{ .Varint = .Simple }), + .DCECFOKFIHH = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PMDKCCPGMDE = struct { + MFNFDHAGAPH: u32 = 0, + + pub const _desc_table = .{ + .MFNFDHAGAPH = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KEDCGGPPBLB = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FCCLHJINFED = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENLDPPNFOGP = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGBEKCNNNJH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFAIOAMFDEM = struct { + retcode: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + .battle_info = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBNELCONAPD = struct { + skill_id: u32 = 0, + + pub const _desc_table = .{ + .skill_id = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NHCJMPNEDDI = struct { + retcode: u32 = 0, + skill_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .skill_id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KMAFPMKGIFP = struct { + BOCEAHMENHD: u32 = 0, + + pub const _desc_table = .{ + .BOCEAHMENHD = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MOFMEKPDOIO = struct { + DAPAKMMMAOJ: ?GDGGKONPNIG = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DAPAKMMMAOJ = fd(5, .{ .SubMessage = {} }), + .retcode = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECDJBHNLCMG = struct { + LHMPHPEODNP: u32 = 0, + + pub const _desc_table = .{ + .LHMPHPEODNP = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PEAGMIKINCF = struct { + retcode: u32 = 0, + LHMPHPEODNP: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .LHMPHPEODNP = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MJLBEIOLCPC = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCBOEDPMHOI = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLBJKLCHJHK = struct { + NLEFHGHGKPE: JKMJAIADMLI = @enumFromInt(0), + PCMAAKHAEBC: u32 = 0, + BOCEAHMENHD: u32 = 0, + DKFLLECGCCK: ArrayList(u32), + CKEDFNKALOI: u32 = 0, + CIDICFBPHAF: ArrayList(u32), + OOJPFKLPHFH: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .NLEFHGHGKPE = fd(2, .{ .Varint = .Simple }), + .PCMAAKHAEBC = fd(1, .{ .Varint = .Simple }), + .BOCEAHMENHD = fd(7, .{ .Varint = .Simple }), + .DKFLLECGCCK = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .CKEDFNKALOI = fd(15, .{ .Varint = .Simple }), + .CIDICFBPHAF = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .OOJPFKLPHFH = fd(6, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AKMPGPMADKO = struct { + AKPGGHKCAIF: ArrayList(DNLEFEGOBEG), + FGCDDCJHIAG: ArrayList(u32), + + pub const _desc_table = .{ + .AKPGGHKCAIF = fd(4, .{ .List = .{ .SubMessage = {} } }), + .FGCDDCJHIAG = fd(9, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OINCIGPNEPL = struct { + JAFLOLLFNDO: u32 = 0, + + pub const _desc_table = .{ + .JAFLOLLFNDO = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AADFHDGJNIH = struct { + retcode: u32 = 0, + LHFFLOKIELE: ?ItemList = null, + JAFLOLLFNDO: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(14, .{ .SubMessage = {} }), + .JAFLOLLFNDO = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCOLJDKGDBN = struct { + OKOANEAKGOE: u32 = 0, + + pub const _desc_table = .{ + .OKOANEAKGOE = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NPJPKIGLBJP = struct { + OKOANEAKGOE: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .OKOANEAKGOE = fd(4, .{ .Varint = .Simple }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPABJCCEADF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KAONBIOFBBD = struct { + DAPAKMMMAOJ: ?GDGGKONPNIG = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .DAPAKMMMAOJ = fd(14, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EFCDNJALEOJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CGNHMHLODCO = struct { + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(8, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBLFCMEHPFO = struct { + LJEPIBBDFNJ: u32 = 0, + NAEKJBOEMCA: u32 = 0, + FEJOAEALKDF: ArrayList(JDHLJLCFKMO), + + pub const _desc_table = .{ + .LJEPIBBDFNJ = fd(2, .{ .Varint = .Simple }), + .NAEKJBOEMCA = fd(6, .{ .Varint = .Simple }), + .FEJOAEALKDF = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HLDHAFGIPOE = struct { + IFMANDPGKIE: u32 = 0, + + pub const _desc_table = .{ + .IFMANDPGKIE = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KLEHMMANNOI = struct { + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(4, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MNABGDHDJAJ = struct { + BOCEAHMENHD: u32 = 0, + + pub const _desc_table = .{ + .BOCEAHMENHD = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPLNOKJDGPC = struct { + retcode: u32 = 0, + DAPAKMMMAOJ: ?GDGGKONPNIG = null, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .DAPAKMMMAOJ = fd(12, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NENMDHEHAKM = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AGAIFKGBKCD = struct { + rank: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .rank = fd(1, .{ .Varint = .Simple }), + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LDBDDLPJEEP = struct { + skill_id: u32 = 0, + + pub const _desc_table = .{ + .skill_id = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BNBHKDENLOE = struct { + retcode: u32 = 0, + skill_id: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .skill_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOABBLFOMLJ = struct { + PHCKLECNFKA: u32 = 0, + stamina: u32 = 0, + + pub const _desc_table = .{ + .PHCKLECNFKA = fd(2, .{ .Varint = .Simple }), + .stamina = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PIEPCJINODB = struct { + PGJNAIKCHPO: bool = false, + MDDDOKFINDH: ManagedString = .Empty, + AFHIBMBDIFB: ArrayList(NPMIAKFMLDB), + + pub const _desc_table = .{ + .PGJNAIKCHPO = fd(12, .{ .Varint = .Simple }), + .MDDDOKFINDH = fd(6, .String), + .AFHIBMBDIFB = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPPOPHNPFHH = struct { + avatar_list: ArrayList(Avatar), + + pub const _desc_table = .{ + .avatar_list = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FJFLOACEAOL = struct { + OABAOJPLIMK: ArrayList(u32), + FJIHBJMIPOE: ArrayList(u32), + FBOGBEPMILE: ArrayList(u32), + MJAPECDHJGM: ArrayList(u32), + CDHGCFEFDMO: ArrayList(Mission), + MKCOMHFLNPP: ArrayList(KMGGNJAKPGI), + ENJONAJDPCK: ArrayList(DOPEKIJOFFE), + + pub const _desc_table = .{ + .OABAOJPLIMK = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .FJIHBJMIPOE = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + .FBOGBEPMILE = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + .MJAPECDHJGM = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .CDHGCFEFDMO = fd(3, .{ .List = .{ .SubMessage = {} } }), + .MKCOMHFLNPP = fd(13, .{ .List = .{ .SubMessage = {} } }), + .ENJONAJDPCK = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HAEFIKOHHBE = struct { + MMAPHKJOECC: ArrayList(Mission), + PAKLCEFFBHJ: ArrayList(u32), + LLFAEMEKDBJ: ArrayList(u32), + + pub const _desc_table = .{ + .MMAPHKJOECC = fd(6, .{ .List = .{ .SubMessage = {} } }), + .PAKLCEFFBHJ = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + .LLFAEMEKDBJ = fd(5, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGCKPLMOOPE = struct { + BANKILOLPNF: ArrayList(NEPMNFEENIB), + OLGFAFGJHBK: ArrayList(JMBMCOPAKEJ), + HFBHDOKMFIF: ArrayList(u32), + relic_list: ArrayList(DADJGGOCGJF), + basic_info: ?PlayerBasicInfo = null, + LJPAABJEKJF: ?HAEFIKOHHBE = null, + NOGKOKELAKC: ArrayList(CJHMEKCHFDH), + AFAPMKPDNAK: ArrayList(GKKAKMDBGAD), + DLCOBFIGMMD: ArrayList(CJHMEKCHFDH), + HKNADMABCGG: ArrayList(PDLCDMEPDDJ), + KPMNKMGMEGA: ArrayList(ILDONLKCIDA), + GLEAJHKCMEA: ?FJFLOACEAOL = null, + LLDHJNLGOPL: u32 = 0, + JKPBHEGMDEC: ?ItemList = null, + PNHFLNFPEOH: ArrayList(MDENNNNBMNC), + equipment_list: ArrayList(LLLPHAJABGB), + BDAAFKGLCIH: ArrayList(u32), + NBMKIAGDPFC: ?JOABBLFOMLJ = null, + HPMECAKIADH: ?LPPOPHNPFHH = null, + FOHEEHNABGN: ArrayList(u32), + IPFJBKOFEDE: ?PIEPCJINODB = null, + + pub const _desc_table = .{ + .BANKILOLPNF = fd(1608, .{ .List = .{ .SubMessage = {} } }), + .OLGFAFGJHBK = fd(576, .{ .List = .{ .SubMessage = {} } }), + .HFBHDOKMFIF = fd(1310, .{ .PackedList = .{ .Varint = .Simple } }), + .relic_list = fd(1, .{ .List = .{ .SubMessage = {} } }), + .basic_info = fd(11, .{ .SubMessage = {} }), + .LJPAABJEKJF = fd(7, .{ .SubMessage = {} }), + .NOGKOKELAKC = fd(935, .{ .List = .{ .SubMessage = {} } }), + .AFAPMKPDNAK = fd(10, .{ .List = .{ .SubMessage = {} } }), + .DLCOBFIGMMD = fd(3, .{ .List = .{ .SubMessage = {} } }), + .HKNADMABCGG = fd(1767, .{ .List = .{ .SubMessage = {} } }), + .KPMNKMGMEGA = fd(176, .{ .List = .{ .SubMessage = {} } }), + .GLEAJHKCMEA = fd(12, .{ .SubMessage = {} }), + .LLDHJNLGOPL = fd(552, .{ .Varint = .Simple }), + .JKPBHEGMDEC = fd(777, .{ .SubMessage = {} }), + .PNHFLNFPEOH = fd(5, .{ .List = .{ .SubMessage = {} } }), + .equipment_list = fd(6, .{ .List = .{ .SubMessage = {} } }), + .BDAAFKGLCIH = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .NBMKIAGDPFC = fd(13, .{ .SubMessage = {} }), + .HPMECAKIADH = fd(9, .{ .SubMessage = {} }), + .FOHEEHNABGN = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + .IPFJBKOFEDE = fd(1569, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BBCHPGPICFH = struct { + npc_id: u32 = 0, + + pub const _desc_table = .{ + .npc_id = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AOEFCNIFJHO = struct { + npc_id: u32 = 0, + LDMEFOKLIOM: ArrayList(u32), + retcode: u32 = 0, + + pub const _desc_table = .{ + .npc_id = fd(2, .{ .Varint = .Simple }), + .LDMEFOKLIOM = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NODIHJHBCFI = struct { + OCCEDKNFKDF: ?Vector = null, + JFANOOOBIEI: u32 = 0, + + pub const _desc_table = .{ + .OCCEDKNFKDF = fd(14, .{ .SubMessage = {} }), + .JFANOOOBIEI = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KJOJBIADAML = struct { + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + JFANOOOBIEI: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(1, .{ .SubMessage = {} }), + .JFANOOOBIEI = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BKPBMCFJKPI = struct { + DAFAEHBFCBG: ArrayList(u32), + + pub const _desc_table = .{ + .DAFAEHBFCBG = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPCJHFDKKPI = struct { + GLLBNLGPJAE: bool = false, + EKMBLBBPGBD: u32 = 0, + + pub const _desc_table = .{ + .GLLBNLGPJAE = fd(7, .{ .Varint = .Simple }), + .EKMBLBBPGBD = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JKIBCPMLEPM = struct { + retcode: u32 = 0, + FIJNOPCINNE: ArrayList(OPCJHFDKKPI), + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .FIJNOPCINNE = fd(14, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HALODLJKCAH = struct { + EKMBLBBPGBD: u32 = 0, + + pub const _desc_table = .{ + .EKMBLBBPGBD = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FILGAJMDAPG = struct { + retcode: u32 = 0, + EKMBLBBPGBD: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .EKMBLBBPGBD = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLBLACIAEDA = struct { + FHAHFILIEDN: u32 = 0, + + pub const _desc_table = .{ + .FHAHFILIEDN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMLIEGFOOML = struct { + FHAHFILIEDN: u32 = 0, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FHAHFILIEDN = fd(1, .{ .Varint = .Simple }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OAKALJFEPLC = struct { + MHPBNMAJAPI: u32 = 0, + GLLBNLGPJAE: bool = false, + + pub const _desc_table = .{ + .MHPBNMAJAPI = fd(3, .{ .Varint = .Simple }), + .GLLBNLGPJAE = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOMCELPDPOG = struct { + AOHPEFHNGHO: ArrayList(u32), + + pub const _desc_table = .{ + .AOHPEFHNGHO = fd(2, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const COKIOEMOPBA = struct { + FIJNOPCINNE: ArrayList(OAKALJFEPLC), + retcode: u32 = 0, + + pub const _desc_table = .{ + .FIJNOPCINNE = fd(9, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MDLPOCIDBKF = struct { + MHPBNMAJAPI: u32 = 0, + + pub const _desc_table = .{ + .MHPBNMAJAPI = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GHJAKEIFPBL = struct { + MHPBNMAJAPI: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .MHPBNMAJAPI = fd(1, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(11, .{ .SubMessage = {} }), + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MBEIFNACMNC = struct { + ICLEAJOGAKJ: u32 = 0, + CFNFMEEMCKK: u32 = 0, + FOGBECBDFDM: u32 = 0, + + pub const _desc_table = .{ + .ICLEAJOGAKJ = fd(12, .{ .Varint = .Simple }), + .CFNFMEEMCKK = fd(4, .{ .Varint = .Simple }), + .FOGBECBDFDM = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CIENPHGMEIG = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NKJJJOKFFDK = struct { + EHIOPHAHPOC: ArrayList(MBEIFNACMNC), + retcode: u32 = 0, + + pub const _desc_table = .{ + .EHIOPHAHPOC = fd(11, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPLMAJBJKOL = struct { + EHIOPHAHPOC: ArrayList(MBEIFNACMNC), + + pub const _desc_table = .{ + .EHIOPHAHPOC = fd(3, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ANOGAFHFHEP = struct { + KKAJPMLOAMH: u32 = 0, + NENNPJOJIEC: u32 = 0, + EGFKGPEBKAP: u32 = 0, + BABGDLHDFHE: u32 = 0, + LDOCCEHNDJP: ?MBEIFNACMNC = null, + + pub const _desc_table = .{ + .KKAJPMLOAMH = fd(9, .{ .Varint = .Simple }), + .NENNPJOJIEC = fd(4, .{ .Varint = .Simple }), + .EGFKGPEBKAP = fd(12, .{ .Varint = .Simple }), + .BABGDLHDFHE = fd(2, .{ .Varint = .Simple }), + .LDOCCEHNDJP = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DGLCMPNDODO = struct { + avatar_id: u32 = 0, + avatar_type: AvatarType = @enumFromInt(0), + + pub const _desc_table = .{ + .avatar_id = fd(5, .{ .Varint = .Simple }), + .avatar_type = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFMJONPFIMJ = struct { + ICLEAJOGAKJ: u32 = 0, + buff_list: ArrayList(u32), + avatar_list: ArrayList(DGLCMPNDODO), + + pub const _desc_table = .{ + .ICLEAJOGAKJ = fd(7, .{ .Varint = .Simple }), + .buff_list = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + .avatar_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BOMOBFGGPNJ = struct { + retcode: u32 = 0, + ICLEAJOGAKJ: u32 = 0, + battle_info: ?SceneBattleInfo = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .ICLEAJOGAKJ = fd(2, .{ .Varint = .Simple }), + .battle_info = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KIOIAMIFFEO = struct { + AACLNHHODCM: ManagedString = .Empty, + DKGEHECJMPC: u32 = 0, + IKCEAFIFJJA: u32 = 0, + CFCJDNAKCNA: ManagedString = .Empty, + JMJMLHDIEFI: u32 = 0, + + pub const _desc_table = .{ + .AACLNHHODCM = fd(14, .String), + .DKGEHECJMPC = fd(12, .{ .Varint = .Simple }), + .IKCEAFIFJJA = fd(10, .{ .Varint = .Simple }), + .CFCJDNAKCNA = fd(3, .String), + .JMJMLHDIEFI = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GNFCHPJAFNK = struct { + DKGEHECJMPC: u32 = 0, + CFCJDNAKCNA: ManagedString = .Empty, + JMJMLHDIEFI: u32 = 0, + + pub const _desc_table = .{ + .DKGEHECJMPC = fd(7, .{ .Varint = .Simple }), + .CFCJDNAKCNA = fd(8, .String), + .JMJMLHDIEFI = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NAGGFJNOOPH = struct { + DKGEHECJMPC: u32 = 0, + retcode: u32 = 0, + JMJMLHDIEFI: u32 = 0, + CFCJDNAKCNA: ManagedString = .Empty, + + pub const _desc_table = .{ + .DKGEHECJMPC = fd(7, .{ .Varint = .Simple }), + .retcode = fd(6, .{ .Varint = .Simple }), + .JMJMLHDIEFI = fd(14, .{ .Varint = .Simple }), + .CFCJDNAKCNA = fd(11, .String), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GCCGNJCEFCC = struct { + GPKMICEFKPI: ArrayList(u32), + + pub const _desc_table = .{ + .GPKMICEFKPI = fd(8, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MBKJLENBAAD = struct { + JCNANJCPLKO: ArrayList(KIOIAMIFFEO), + retcode: u32 = 0, + + pub const _desc_table = .{ + .JCNANJCPLKO = fd(10, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPNOIBBKMHH = struct { + JCNANJCPLKO: ArrayList(KIOIAMIFFEO), + + pub const _desc_table = .{ + .JCNANJCPLKO = fd(12, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MEJKOBBDNMJ = struct { + JCNANJCPLKO: ArrayList(KIOIAMIFFEO), + retcode: u32 = 0, + + pub const _desc_table = .{ + .JCNANJCPLKO = fd(4, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OIKBJJGIKIM = struct { + stage_id: u32 = 0, + FOGBECBDFDM: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(14, .{ .Varint = .Simple }), + .FOGBECBDFDM = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DCLGDBHJIGJ = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HAIDDMFMEJA = struct { + retcode: u32 = 0, + PAACMCDBGFN: ArrayList(OIKBJJGIKIM), + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + .PAACMCDBGFN = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPPPJAPJLAE = struct { + entity_id: u32 = 0, + OICNDNPKCMP: bool = false, + + pub const _desc_table = .{ + .entity_id = fd(8, .{ .Varint = .Simple }), + .OICNDNPKCMP = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FOPNPMKJPKP = struct { + cost_time: u32 = 0, + NFBNCOGLIBK: ArrayList(LPPPJAPJLAE), + stage_id: u32 = 0, + + pub const _desc_table = .{ + .cost_time = fd(6, .{ .Varint = .Simple }), + .NFBNCOGLIBK = fd(7, .{ .List = .{ .SubMessage = {} } }), + .stage_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JEBNBLKOPFJ = struct { + retcode: u32 = 0, + NFBNCOGLIBK: ArrayList(LPPPJAPJLAE), + stage_id: u32 = 0, + FDDOLEGBPHH: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .NFBNCOGLIBK = fd(13, .{ .List = .{ .SubMessage = {} } }), + .stage_id = fd(3, .{ .Varint = .Simple }), + .FDDOLEGBPHH = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KECPIMHGGIB = struct { + stage_id: u32 = 0, + BKNGCLADOAN: bool = false, + + pub const _desc_table = .{ + .stage_id = fd(2, .{ .Varint = .Simple }), + .BKNGCLADOAN = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KGFLKOHAKJJ = struct { + retcode: u32 = 0, + JPPIHHBHDLA: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + .JPPIHHBHDLA = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OFLIBBNALLM = struct { + stage_id: u32 = 0, + + pub const _desc_table = .{ + .stage_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJNFMDDHKJA = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKCAHBDIABL = struct { + GLLBNLGPJAE: bool = false, + KKHCGIBNEED: u32 = 0, + + pub const _desc_table = .{ + .GLLBNLGPJAE = fd(7, .{ .Varint = .Simple }), + .KKHCGIBNEED = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NLMHIHMBIHM = struct { + KKHCGIBNEED: u32 = 0, + + pub const _desc_table = .{ + .KKHCGIBNEED = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMBDEGPCNPF = struct { + retcode: u32 = 0, + ADKJIIANOOM: ?ItemList = null, + KKHCGIBNEED: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(3, .{ .SubMessage = {} }), + .KKHCGIBNEED = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABACLCIDGPD = struct { + EBLEJLDNEPO: ArrayList(u32), + + pub const _desc_table = .{ + .EBLEJLDNEPO = fd(10, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IEAOJEFCDAF = struct { + retcode: u32 = 0, + AKCPCBCGJJI: ArrayList(OKCAHBDIABL), + + pub const _desc_table = .{ + .retcode = fd(3, .{ .Varint = .Simple }), + .AKCPCBCGJJI = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCOKAFGAKGF = struct { + GKMGNHKLCNO: u64 = 0, + + pub const _desc_table = .{ + .GKMGNHKLCNO = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HDNALOAECOB = struct { + EEOLCCFMJFF: GGMLOIDBIBC = @enumFromInt(0), + ADKJIIANOOM: ?ItemList = null, + KKHCGIBNEED: u32 = 0, + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(3, .{ .Varint = .Simple }), + .ADKJIIANOOM = fd(10, .{ .SubMessage = {} }), + .KKHCGIBNEED = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFCBABINJID = struct { + CEOBDAFELDP: bool = false, + KKHCGIBNEED: u32 = 0, + AAHILCBEFAD: u32 = 0, + status: EKHNDMBIDHH = @enumFromInt(0), + GLLHDKKCGPM: ArrayList(u32), + + pub const _desc_table = .{ + .CEOBDAFELDP = fd(15, .{ .Varint = .Simple }), + .KKHCGIBNEED = fd(1, .{ .Varint = .Simple }), + .AAHILCBEFAD = fd(12, .{ .Varint = .Simple }), + .status = fd(6, .{ .Varint = .Simple }), + .GLLHDKKCGPM = fd(4, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHMPDCECOIB = struct { + EEOLCCFMJFF: AILCFBABHIN = @enumFromInt(0), + + pub const _desc_table = .{ + .EEOLCCFMJFF = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPHEHCNLLBC = struct { + LJMEJPFMMNO: ArrayList(u32), + GLECBMOELEN: ArrayList(IFCBABINJID), + retcode: u32 = 0, + + pub const _desc_table = .{ + .LJMEJPFMMNO = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + .GLECBMOELEN = fd(15, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LLABOJLNIKA = struct { + KKHCGIBNEED: u32 = 0, + + pub const _desc_table = .{ + .KKHCGIBNEED = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PPJEDLDCNML = struct { + retcode: u32 = 0, + KKHCGIBNEED: u32 = 0, + GLLHDKKCGPM: ArrayList(u32), + + pub const _desc_table = .{ + .retcode = fd(9, .{ .Varint = .Simple }), + .KKHCGIBNEED = fd(6, .{ .Varint = .Simple }), + .GLLHDKKCGPM = fd(1, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBJPMNLLIFD = struct { + LJMEJPFMMNO: ArrayList(u32), + + pub const _desc_table = .{ + .LJMEJPFMMNO = fd(13, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GLFMMCHMJDP = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OOOJKGDMFOK = struct { + GHILCJBAECL: i32 = 0, + GBIEPAPENKJ: u32 = 0, + unique_id: u64 = 0, + PABCGEDNCGH: u32 = 0, + FNIHLGCEICD: u32 = 0, + MKAGLPGEPBP: i32 = 0, + + pub const _desc_table = .{ + .GHILCJBAECL = fd(12, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(11, .{ .Varint = .Simple }), + .unique_id = fd(14, .{ .Varint = .Simple }), + .PABCGEDNCGH = fd(8, .{ .Varint = .Simple }), + .FNIHLGCEICD = fd(1, .{ .Varint = .Simple }), + .MKAGLPGEPBP = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OHBCINICBHP = struct { + FGPDKJPAKNC: MEMCBKNIBAJ = @enumFromInt(0), + HKOOAJAOJFJ: DAADHEDHJNH = @enumFromInt(0), + HHMPIBMIHJA: u32 = 0, + OCKLJIFBFIN: u32 = 0, + DBKFLOBAMAE: ArrayList(OOOJKGDMFOK), + + pub const _desc_table = .{ + .FGPDKJPAKNC = fd(1, .{ .Varint = .Simple }), + .HKOOAJAOJFJ = fd(9, .{ .Varint = .Simple }), + .HHMPIBMIHJA = fd(2, .{ .Varint = .Simple }), + .OCKLJIFBFIN = fd(6, .{ .Varint = .Simple }), + .DBKFLOBAMAE = fd(4, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHIJKHGIEEF = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MBANAOCOPCD = struct { + JPBPMIKDLNB: u32 = 0, + retcode: u32 = 0, + OLDHAJNFNHA: ArrayList(OLDHAJNFNHAEntry), + BPBFCBCLMKL: ArrayList(BPBFCBCLMKLEntry), + + pub const _desc_table = .{ + .JPBPMIKDLNB = fd(3, .{ .Varint = .Simple }), + .retcode = fd(7, .{ .Varint = .Simple }), + .OLDHAJNFNHA = fd(4, .{ .List = .{ .SubMessage = {} } }), + .BPBFCBCLMKL = fd(6, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const OLDHAJNFNHAEntry = struct { + key: u32 = 0, + value: ?OHBCINICBHP = null, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const BPBFCBCLMKLEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KCIKECAFNJC = struct { + HHMPIBMIHJA: u32 = 0, + + pub const _desc_table = .{ + .HHMPIBMIHJA = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JOLPOFBBFNP = struct { + HHMPIBMIHJA: u32 = 0, + OCKLJIFBFIN: u32 = 0, + + pub const _desc_table = .{ + .HHMPIBMIHJA = fd(8, .{ .Varint = .Simple }), + .OCKLJIFBFIN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GMACADIBAAI = struct { + CJNINFNKNML: ?OHBCINICBHP = null, + ADKJIIANOOM: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CJNINFNKNML = fd(1, .{ .SubMessage = {} }), + .ADKJIIANOOM = fd(5, .{ .SubMessage = {} }), + .retcode = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIMPPEEIGBA = struct { + PABCGEDNCGH: u32 = 0, + GBIEPAPENKJ: u32 = 0, + HHMPIBMIHJA: u32 = 0, + FNIHLGCEICD: u32 = 0, + GHILCJBAECL: i32 = 0, + MKAGLPGEPBP: i32 = 0, + + pub const _desc_table = .{ + .PABCGEDNCGH = fd(14, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(3, .{ .Varint = .Simple }), + .HHMPIBMIHJA = fd(6, .{ .Varint = .Simple }), + .FNIHLGCEICD = fd(4, .{ .Varint = .Simple }), + .GHILCJBAECL = fd(15, .{ .Varint = .Simple }), + .MKAGLPGEPBP = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LIHMHBLIMAB = struct { + retcode: u32 = 0, + CJNINFNKNML: ?OHBCINICBHP = null, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .CJNINFNKNML = fd(10, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNAKHKOMKDJ = struct { + HHMPIBMIHJA: u32 = 0, + GBIEPAPENKJ: u32 = 0, + unique_id: u64 = 0, + + pub const _desc_table = .{ + .HHMPIBMIHJA = fd(10, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(8, .{ .Varint = .Simple }), + .unique_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AJEDDJFHDBD = struct { + CJNINFNKNML: ?OHBCINICBHP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CJNINFNKNML = fd(15, .{ .SubMessage = {} }), + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKIFDHOPFCJ = struct { + FNIHLGCEICD: u32 = 0, + GBIEPAPENKJ: u32 = 0, + unique_id: u64 = 0, + GHILCJBAECL: i32 = 0, + MKAGLPGEPBP: i32 = 0, + PABCGEDNCGH: u32 = 0, + HHMPIBMIHJA: u32 = 0, + + pub const _desc_table = .{ + .FNIHLGCEICD = fd(10, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(15, .{ .Varint = .Simple }), + .unique_id = fd(2, .{ .Varint = .Simple }), + .GHILCJBAECL = fd(14, .{ .Varint = .Simple }), + .MKAGLPGEPBP = fd(12, .{ .Varint = .Simple }), + .PABCGEDNCGH = fd(1, .{ .Varint = .Simple }), + .HHMPIBMIHJA = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ICLFALIGJDG = struct { + retcode: u32 = 0, + CJNINFNKNML: ?OHBCINICBHP = null, + + pub const _desc_table = .{ + .retcode = fd(10, .{ .Varint = .Simple }), + .CJNINFNKNML = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NIAOHNKKNOI = struct { + DEMNFFJKLEJ: u32 = 0, + NHFGFOCFGCG: u32 = 0, + + pub const _desc_table = .{ + .DEMNFFJKLEJ = fd(6, .{ .Varint = .Simple }), + .NHFGFOCFGCG = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILDONLKCIDA = struct { + NHFGFOCFGCG: u32 = 0, + DEMNFFJKLEJ: u32 = 0, + + pub const _desc_table = .{ + .NHFGFOCFGCG = fd(15, .{ .Varint = .Simple }), + .DEMNFFJKLEJ = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KHPHLLNONKP = struct { + value: u32 = 0, + + pub const _desc_table = .{ + .value = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ECLOFJDAGGK = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MHIKPMGOGMP = struct { + MCEJAINEAIE: DAADHEDHJNH = @enumFromInt(0), + HHMPIBMIHJA: u32 = 0, + + pub const _desc_table = .{ + .MCEJAINEAIE = fd(4, .{ .Varint = .Simple }), + .HHMPIBMIHJA = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NMHAMJOLKML = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FFIKGBBILDJ = struct { + HHMPIBMIHJA: u32 = 0, + + pub const _desc_table = .{ + .HHMPIBMIHJA = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KPGEMPLIEAL = struct { + CJNINFNKNML: ?OHBCINICBHP = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .CJNINFNKNML = fd(5, .{ .SubMessage = {} }), + .retcode = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OKEHCMBIGGF = struct { + FNIHLGCEICD: u32 = 0, + GBIEPAPENKJ: u32 = 0, + PABCGEDNCGH: u32 = 0, + MKAGLPGEPBP: i32 = 0, + GHILCJBAECL: i32 = 0, + + pub const _desc_table = .{ + .FNIHLGCEICD = fd(4, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(6, .{ .Varint = .Simple }), + .PABCGEDNCGH = fd(15, .{ .Varint = .Simple }), + .MKAGLPGEPBP = fd(8, .{ .Varint = .Simple }), + .GHILCJBAECL = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDJOGILIINE = struct { + HHMPIBMIHJA: u32 = 0, + DOAMLPGPOMJ: ArrayList(OKEHCMBIGGF), + + pub const _desc_table = .{ + .HHMPIBMIHJA = fd(14, .{ .Varint = .Simple }), + .DOAMLPGPOMJ = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MGBHAOKFAAM = struct { + retcode: u32 = 0, + CJNINFNKNML: ?OHBCINICBHP = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .CJNINFNKNML = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const TreasureDungeonRecordData = struct { + source_grid_id: u32 = 0, + type: HOIAHNPBDOB = @enumFromInt(0), + param_1: u32 = 0, + target_grid_id: u32 = 0, + param_2: u32 = 0, + + pub const _desc_table = .{ + .source_grid_id = fd(9, .{ .Varint = .Simple }), + .type = fd(15, .{ .Varint = .Simple }), + .param_1 = fd(5, .{ .Varint = .Simple }), + .target_grid_id = fd(2, .{ .Varint = .Simple }), + .param_2 = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HPIEIJMODDB = struct { + ANGLIEBKBBM: ?MMKDMHFIFNF = null, + + pub const _desc_table = .{ + .ANGLIEBKBBM = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEKLBCCCKNJ = struct { + LDAMNJPGJOC: bool = false, + OJAKLOFFLKC: u32 = 0, + OBDPHAENPGO: ArrayList(OBDPHAENPGOEntry), + JIEHDHEANNK: u32 = 0, + BKFEABHCNKF: u32 = 0, + NBCIOOOIAND: u32 = 0, + IIKGNNOJIMC: ArrayList(IIKGNNOJIMCEntry), + + pub const _desc_table = .{ + .LDAMNJPGJOC = fd(12, .{ .Varint = .Simple }), + .OJAKLOFFLKC = fd(13, .{ .Varint = .Simple }), + .OBDPHAENPGO = fd(2, .{ .List = .{ .SubMessage = {} } }), + .JIEHDHEANNK = fd(7, .{ .Varint = .Simple }), + .BKFEABHCNKF = fd(6, .{ .Varint = .Simple }), + .NBCIOOOIAND = fd(4, .{ .Varint = .Simple }), + .IIKGNNOJIMC = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub const OBDPHAENPGOEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub const IIKGNNOJIMCEntry = struct { + key: u32 = 0, + value: u32 = 0, + + pub const _desc_table = .{ + .key = fd(1, .{ .Varint = .Simple }), + .value = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MMKDMHFIFNF = struct { + BKFEABHCNKF: u32 = 0, + BOEFMHFDNCM: ArrayList(TreasureDungeonRecordData), + DKBCFCPKELN: bool = false, + avatar_list: ArrayList(OMAGJFAGNLH), + OFEMOANLCIO: u32 = 0, + LHFFLOKIELE: ArrayList(KBJKOKHJOGF), + JIEHDHEANNK: u32 = 0, + PFMACGECCAG: ArrayList(HEEENFFOBLE), + NBHGGLCOJCD: u32 = 0, + LNGPLFNBEDN: bool = false, + buff_list: ArrayList(EELOILJMJKN), + LJJDNLFCPMF: bool = false, + BFAOFHNBPNA: ArrayList(NFJAKOCBDCP), + PGOHBDFNLAO: u32 = 0, + EGKOJHEIOHH: u32 = 0, + BDOEPLHLHNL: ArrayList(OMAGJFAGNLH), + MBJGCOMPGHP: u32 = 0, + BFHEILPBKNA: u32 = 0, + + pub const _desc_table = .{ + .BKFEABHCNKF = fd(5, .{ .Varint = .Simple }), + .BOEFMHFDNCM = fd(7, .{ .List = .{ .SubMessage = {} } }), + .DKBCFCPKELN = fd(1449, .{ .Varint = .Simple }), + .avatar_list = fd(262, .{ .List = .{ .SubMessage = {} } }), + .OFEMOANLCIO = fd(6, .{ .Varint = .Simple }), + .LHFFLOKIELE = fd(1943, .{ .List = .{ .SubMessage = {} } }), + .JIEHDHEANNK = fd(8, .{ .Varint = .Simple }), + .PFMACGECCAG = fd(1, .{ .List = .{ .SubMessage = {} } }), + .NBHGGLCOJCD = fd(1227, .{ .Varint = .Simple }), + .LNGPLFNBEDN = fd(1590, .{ .Varint = .Simple }), + .buff_list = fd(1448, .{ .List = .{ .SubMessage = {} } }), + .LJJDNLFCPMF = fd(708, .{ .Varint = .Simple }), + .BFAOFHNBPNA = fd(955, .{ .List = .{ .SubMessage = {} } }), + .PGOHBDFNLAO = fd(9, .{ .Varint = .Simple }), + .EGKOJHEIOHH = fd(3, .{ .Varint = .Simple }), + .BDOEPLHLHNL = fd(387, .{ .List = .{ .SubMessage = {} } }), + .MBJGCOMPGHP = fd(14, .{ .Varint = .Simple }), + .BFHEILPBKNA = fd(10, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KBJKOKHJOGF = struct { + GBIEPAPENKJ: u32 = 0, + DJOAJNAHOKB: u32 = 0, + + pub const _desc_table = .{ + .GBIEPAPENKJ = fd(4, .{ .Varint = .Simple }), + .DJOAJNAHOKB = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OMAGJFAGNLH = struct { + avatar_type: u32 = 0, + CJBHMBBJBHO: u32 = 0, + hp: u32 = 0, + sp: ?SpProgress = null, + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(3, .{ .Varint = .Simple }), + .CJBHMBBJBHO = fd(4, .{ .Varint = .Simple }), + .hp = fd(11, .{ .Varint = .Simple }), + .sp = fd(1, .{ .SubMessage = {} }), + .avatar_id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NFJAKOCBDCP = struct { + avatar_id: u32 = 0, + avatar_type: u32 = 0, + + pub const _desc_table = .{ + .avatar_id = fd(1, .{ .Varint = .Simple }), + .avatar_type = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EELOILJMJKN = struct { + PMAFAOLJFBH: u32 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .PMAFAOLJFBH = fd(4, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HEEENFFOBLE = struct { + NMBPIEBNJPG: bool = false, + OJNOMLGBILP: bool = false, + HPHCAEDDOCM: u32 = 0, + ALNBFFGIKNM: bool = false, + HHPDJFILHLP: u32 = 0, + DBENCJELCIF: bool = false, + CIDDCGHFFOC: u32 = 0, + buff_list: ArrayList(OLMNOHDHFHN), + + pub const _desc_table = .{ + .NMBPIEBNJPG = fd(9, .{ .Varint = .Simple }), + .OJNOMLGBILP = fd(7, .{ .Varint = .Simple }), + .HPHCAEDDOCM = fd(15, .{ .Varint = .Simple }), + .ALNBFFGIKNM = fd(14, .{ .Varint = .Simple }), + .HHPDJFILHLP = fd(1, .{ .Varint = .Simple }), + .DBENCJELCIF = fd(10, .{ .Varint = .Simple }), + .CIDDCGHFFOC = fd(6, .{ .Varint = .Simple }), + .buff_list = fd(1456, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OLMNOHDHFHN = struct { + ABPEOMCFMAB: u32 = 0, + CIDDCGHFFOC: u32 = 0, + BLHKNGMAPIO: u32 = 0, + CCMGFFKPJIF: u32 = 0, + NOJPMGONLPN: u32 = 0, + + pub const _desc_table = .{ + .ABPEOMCFMAB = fd(4, .{ .Varint = .Simple }), + .CIDDCGHFFOC = fd(1, .{ .Varint = .Simple }), + .BLHKNGMAPIO = fd(6, .{ .Varint = .Simple }), + .CCMGFFKPJIF = fd(2, .{ .Varint = .Simple }), + .NOJPMGONLPN = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const EHLEDKHLFFB = struct { + JIEHDHEANNK: u32 = 0, + EONHGGGJGCC: bool = false, + FHMGJHNHAFM: bool = false, + OECDAPDCDEN: u32 = 0, + BKFEABHCNKF: u32 = 0, + PGOHBDFNLAO: u32 = 0, + BFHEILPBKNA: u32 = 0, + + pub const _desc_table = .{ + .JIEHDHEANNK = fd(3, .{ .Varint = .Simple }), + .EONHGGGJGCC = fd(10, .{ .Varint = .Simple }), + .FHMGJHNHAFM = fd(9, .{ .Varint = .Simple }), + .OECDAPDCDEN = fd(13, .{ .Varint = .Simple }), + .BKFEABHCNKF = fd(6, .{ .Varint = .Simple }), + .PGOHBDFNLAO = fd(1, .{ .Varint = .Simple }), + .BFHEILPBKNA = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LHJINHKIGGK = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BALKMGKIKEK = struct { + LFFHFFGIEOF: ArrayList(EHLEDKHLFFB), + retcode: u32 = 0, + + pub const _desc_table = .{ + .LFFHFFGIEOF = fd(4, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NBCMGHKAGEK = struct { + BKFEABHCNKF: u32 = 0, + avatar_list: ArrayList(ABNIFJLPPPI), + + pub const _desc_table = .{ + .BKFEABHCNKF = fd(5, .{ .Varint = .Simple }), + .avatar_list = fd(15, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCHGIALCDED = struct { + retcode: u32 = 0, + ANGLIEBKBBM: ?MMKDMHFIFNF = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .ANGLIEBKBBM = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GGBNCIJFAJA = struct { + BKFEABHCNKF: u32 = 0, + CIDDCGHFFOC: u32 = 0, + + pub const _desc_table = .{ + .BKFEABHCNKF = fd(15, .{ .Varint = .Simple }), + .CIDDCGHFFOC = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const OPBINGOFNDO = struct { + ANGLIEBKBBM: ?MMKDMHFIFNF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ANGLIEBKBBM = fd(7, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNGEEEGPEMO = struct { + CIDDCGHFFOC: u32 = 0, + BKFEABHCNKF: u32 = 0, + FJOJLFMCPKP: u32 = 0, + + pub const _desc_table = .{ + .CIDDCGHFFOC = fd(12, .{ .Varint = .Simple }), + .BKFEABHCNKF = fd(8, .{ .Varint = .Simple }), + .FJOJLFMCPKP = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AINDCGOICHN = struct { + ANGLIEBKBBM: ?MMKDMHFIFNF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .ANGLIEBKBBM = fd(2, .{ .SubMessage = {} }), + .retcode = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AIDDJIMEMGB = struct { + BKFEABHCNKF: u32 = 0, + CIDDCGHFFOC: u32 = 0, + GBIEPAPENKJ: u32 = 0, + + pub const _desc_table = .{ + .BKFEABHCNKF = fd(2, .{ .Varint = .Simple }), + .CIDDCGHFFOC = fd(11, .{ .Varint = .Simple }), + .GBIEPAPENKJ = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const COCDOHHCKNN = struct { + retcode: u32 = 0, + ANGLIEBKBBM: ?MMKDMHFIFNF = null, + + pub const _desc_table = .{ + .retcode = fd(15, .{ .Varint = .Simple }), + .ANGLIEBKBBM = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ABNIFJLPPPI = struct { + avatar_type: AvatarType = @enumFromInt(0), + avatar_id: u32 = 0, + + pub const _desc_table = .{ + .avatar_type = fd(4, .{ .Varint = .Simple }), + .avatar_id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CLPEIFNKDNE = struct { + BKFEABHCNKF: u32 = 0, + CIDDCGHFFOC: u32 = 0, + avatar_list: ArrayList(ABNIFJLPPPI), + + pub const _desc_table = .{ + .BKFEABHCNKF = fd(3, .{ .Varint = .Simple }), + .CIDDCGHFFOC = fd(4, .{ .Varint = .Simple }), + .avatar_list = fd(13, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFBOCJGJLMJ = struct { + battle_info: ?SceneBattleInfo = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .battle_info = fd(1, .{ .SubMessage = {} }), + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CEHOMPEGDBE = struct { + BKFEABHCNKF: u32 = 0, + DANADLDDKHJ: bool = false, + + pub const _desc_table = .{ + .BKFEABHCNKF = fd(15, .{ .Varint = .Simple }), + .DANADLDDKHJ = fd(14, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IFGPBFNPOMD = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const Tutorial = struct { + id: u32 = 0, + status: TutorialStatus = @enumFromInt(0), + + pub const _desc_table = .{ + .id = fd(6, .{ .Varint = .Simple }), + .status = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const TutorialGuide = struct { + id: u32 = 0, + status: TutorialStatus = @enumFromInt(0), + + pub const _desc_table = .{ + .id = fd(12, .{ .Varint = .Simple }), + .status = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FLLKDMGJBGH = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetTutorialScRsp = struct { + tutorial_list: ArrayList(Tutorial), + retcode: u32 = 0, + + pub const _desc_table = .{ + .tutorial_list = fd(3, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const MPFDFMLCPFD = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GetTutorialGuideScRsp = struct { + tutorial_guide_list: ArrayList(TutorialGuide), + retcode: u32 = 0, + + pub const _desc_table = .{ + .tutorial_guide_list = fd(6, .{ .List = .{ .SubMessage = {} } }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JCHKGPEIFOA = struct { + MHLKJDKLHFD: u32 = 0, + + pub const _desc_table = .{ + .MHLKJDKLHFD = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const UnlockTutorialScRsp = struct { + tutorial: ?Tutorial = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .tutorial = fd(14, .{ .SubMessage = {} }), + .retcode = fd(15, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HCKEACCFDGI = struct { + group_id: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const UnlockTutorialGuideScRsp = struct { + tutorial_guide: ?TutorialGuide = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .tutorial_guide = fd(12, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KIKKDACAFMF = struct { + MHLKJDKLHFD: u32 = 0, + + pub const _desc_table = .{ + .MHLKJDKLHFD = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FinishTutorialScRsp = struct { + retcode: u32 = 0, + tutorial: ?Tutorial = null, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .tutorial = fd(1, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELPHMHCPLID = struct { + group_id: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FinishTutorialGuideScRsp = struct { + tutorial_guide: ?TutorialGuide = null, + reward: ?ItemList = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .tutorial_guide = fd(2, .{ .SubMessage = {} }), + .reward = fd(5, .{ .SubMessage = {} }), + .retcode = fd(12, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DLDJBOAIBDF = struct { + FHFIGBKCGIF: bool = false, + id: u32 = 0, + GOOKBDEFBOD: u32 = 0, + + pub const _desc_table = .{ + .FHFIGBKCGIF = fd(10, .{ .Varint = .Simple }), + .id = fd(12, .{ .Varint = .Simple }), + .GOOKBDEFBOD = fd(11, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const CBGIHJCLCIP = struct { + FHFIGBKCGIF: bool = false, + JJHKMECJHNN: u32 = 0, + MHHNGINCLLE: ArrayList(u32), + id: u32 = 0, + + pub const _desc_table = .{ + .FHFIGBKCGIF = fd(12, .{ .Varint = .Simple }), + .JJHKMECJHNN = fd(6, .{ .Varint = .Simple }), + .MHHNGINCLLE = fd(11, .{ .PackedList = .{ .Varint = .Simple } }), + .id = fd(3, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const IJIJLCAJFHP = struct { + PCOLGCHAGKA: ?CBGIHJCLCIP = null, + GMFAJBCGDNJ: ArrayList(DLDJBOAIBDF), + + pub const _desc_table = .{ + .PCOLGCHAGKA = fd(12, .{ .SubMessage = {} }), + .GMFAJBCGDNJ = fd(7, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BANEEIFHMPO = struct { + IIHCNNGOLBE: u32 = 0, + + pub const _desc_table = .{ + .IIHCNNGOLBE = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FMGKKJNACFC = struct { + retcode: u32 = 0, + FECKIMGMLKA: u32 = 0, + FCDKNCOBMMF: ?IJIJLCAJFHP = null, + + pub const _desc_table = .{ + .retcode = fd(2, .{ .Varint = .Simple }), + .FECKIMGMLKA = fd(13, .{ .Varint = .Simple }), + .FCDKNCOBMMF = fd(5, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PCGFGBIHALK = struct { + BFLMLHEOOFD: u32 = 0, + + pub const _desc_table = .{ + .BFLMLHEOOFD = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JEJMNHOICJJ = struct { + retcode: u32 = 0, + FECKIMGMLKA: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + .FECKIMGMLKA = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const JDODHNABNLB = struct { + pub const _desc_table = .{}; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILDMNNBCKPJ = struct { + FECKIMGMLKA: u32 = 0, + retcode: u32 = 0, + CAINOCIDFGO: ArrayList(CBGIHJCLCIP), + + pub const _desc_table = .{ + .FECKIMGMLKA = fd(4, .{ .Varint = .Simple }), + .retcode = fd(10, .{ .Varint = .Simple }), + .CAINOCIDFGO = fd(1, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DAOACFOLEJC = struct { + BFLMLHEOOFD: u32 = 0, + IIHCNNGOLBE: u32 = 0, + + pub const _desc_table = .{ + .BFLMLHEOOFD = fd(12, .{ .Varint = .Simple }), + .IIHCNNGOLBE = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PJKOGJKNFLM = struct { + JKGBOKIAOJA: u32 = 0, + IIHCNNGOLBE: u32 = 0, + + pub const _desc_table = .{ + .JKGBOKIAOJA = fd(10, .{ .Varint = .Simple }), + .IIHCNNGOLBE = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DMKBAEJINIK = struct { + JKGBOKIAOJA: u32 = 0, + retcode: u32 = 0, + IIHCNNGOLBE: u32 = 0, + + pub const _desc_table = .{ + .JKGBOKIAOJA = fd(6, .{ .Varint = .Simple }), + .retcode = fd(4, .{ .Varint = .Simple }), + .IIHCNNGOLBE = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const BCIBPAJIMIN = struct { + GBIGNOLAHAB: bool = false, + motion: ?MotionInfo = null, + GLGGCAOMDFP: u32 = 0, + OFKIBKELOKH: ArrayList(Vector), + + pub const _desc_table = .{ + .GBIGNOLAHAB = fd(2, .{ .Varint = .Simple }), + .motion = fd(1, .{ .SubMessage = {} }), + .GLGGCAOMDFP = fd(6, .{ .Varint = .Simple }), + .OFKIBKELOKH = fd(9, .{ .List = .{ .SubMessage = {} } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PGPKOCPBNEF = struct { + OFKIBKELOKH: ArrayList(Vector), + GLGGCAOMDFP: u32 = 0, + id: u32 = 0, + AJPBDPPHGHC: ManagedString = .Empty, + GBIGNOLAHAB: bool = false, + DIPHBDEBFJH: ?BCIBPAJIMIN = null, + + pub const _desc_table = .{ + .OFKIBKELOKH = fd(11, .{ .List = .{ .SubMessage = {} } }), + .GLGGCAOMDFP = fd(10, .{ .Varint = .Simple }), + .id = fd(4, .{ .Varint = .Simple }), + .AJPBDPPHGHC = fd(9, .String), + .GBIGNOLAHAB = fd(13, .{ .Varint = .Simple }), + .DIPHBDEBFJH = fd(15, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const GKBNIDEGEPL = struct { + motion: ?MotionInfo = null, + id: u32 = 0, + JKOCNPOAEEJ: ?FPLBOJJGBHN = null, + BKNGCLADOAN: bool = false, + + pub const _desc_table = .{ + .motion = fd(14, .{ .SubMessage = {} }), + .id = fd(13, .{ .Varint = .Simple }), + .JKOCNPOAEEJ = fd(8, .{ .SubMessage = {} }), + .BKNGCLADOAN = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ILJLKLFGEBN = struct { + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FKNOFJNAFAD = fd(12, .{ .SubMessage = {} }), + .retcode = fd(1, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DNJJCDIJJOB = struct { + motion: ?MotionInfo = null, + id: u32 = 0, + + pub const _desc_table = .{ + .motion = fd(8, .{ .SubMessage = {} }), + .id = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PHKHPFEEGJE = struct { + retcode: u32 = 0, + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + + pub const _desc_table = .{ + .retcode = fd(6, .{ .Varint = .Simple }), + .FKNOFJNAFAD = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AFLLIOENIOC = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LAILCDKJLIE = struct { + retcode: u32 = 0, + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + + pub const _desc_table = .{ + .retcode = fd(12, .{ .Varint = .Simple }), + .FKNOFJNAFAD = fd(9, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const PBOHAGGGNDH = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(2, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FEDGLBKICAK = struct { + retcode: u32 = 0, + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + + pub const _desc_table = .{ + .retcode = fd(8, .{ .Varint = .Simple }), + .FKNOFJNAFAD = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LPAHFBMBOFM = struct { + id: u32 = 0, + + pub const _desc_table = .{ + .id = fd(9, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NOEIMEGHABJ = struct { + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FKNOFJNAFAD = fd(7, .{ .SubMessage = {} }), + .retcode = fd(4, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ELJOKCMKHLM = struct { + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + + pub const _desc_table = .{ + .FKNOFJNAFAD = fd(3, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const KFNJAJDJDLG = struct { + DKJHOHCAKND: ?Vector = null, + HJFNCLOKAON: ArrayList(u32), + + pub const _desc_table = .{ + .DKJHOHCAKND = fd(3, .{ .SubMessage = {} }), + .HJFNCLOKAON = fd(14, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const AOGKIEPICPJ = struct { + retcode: u32 = 0, + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + + pub const _desc_table = .{ + .retcode = fd(13, .{ .Varint = .Simple }), + .FKNOFJNAFAD = fd(11, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const LNDNAFGMJCI = struct { + DKJHOHCAKND: ?Vector = null, + + pub const _desc_table = .{ + .DKJHOHCAKND = fd(8, .{ .SubMessage = {} }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FIHBNPDEJGL = struct { + FKNOFJNAFAD: ?PGPKOCPBNEF = null, + retcode: u32 = 0, + + pub const _desc_table = .{ + .FKNOFJNAFAD = fd(1, .{ .SubMessage = {} }), + .retcode = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const HNPIGILOMIP = struct { + group_id: u32 = 0, + DGFLHAEFBEP: u32 = 0, + + pub const _desc_table = .{ + .group_id = fd(1, .{ .Varint = .Simple }), + .DGFLHAEFBEP = fd(6, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const FKOOJNHGMGB = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(7, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const NEODIEEPLHF = struct { + HJFNCLOKAON: ArrayList(u32), + + pub const _desc_table = .{ + .HJFNCLOKAON = fd(3, .{ .PackedList = .{ .Varint = .Simple } }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const DIPJOJJGHJL = struct { + retcode: u32 = 0, + + pub const _desc_table = .{ + .retcode = fd(5, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; + +pub const ENNFNKLHOGO = struct { + JNBOBGJCBLP: u32 = 0, + LIKAEKCNMHN: u32 = 0, + FFONFIGCNEL: u32 = 0, + EKHLFGDAKBD: u32 = 0, + ECGNDKDBDPG: u32 = 0, + ONHDJOGHNEB: u32 = 0, + FLOJGFEFKOI: u32 = 0, + PPNLNPMEMOI: u32 = 0, + BMBEBCGLFIF: u32 = 0, + ICHGDINBBFN: u32 = 0, + id: u32 = 0, + NJDDHGADECD: u32 = 0, + HAIIAPOODBB: u32 = 0, + + pub const _desc_table = .{ + .JNBOBGJCBLP = fd(1, .{ .Varint = .Simple }), + .LIKAEKCNMHN = fd(2, .{ .Varint = .Simple }), + .FFONFIGCNEL = fd(3, .{ .Varint = .Simple }), + .EKHLFGDAKBD = fd(4, .{ .Varint = .Simple }), + .ECGNDKDBDPG = fd(5, .{ .Varint = .Simple }), + .ONHDJOGHNEB = fd(6, .{ .Varint = .Simple }), + .FLOJGFEFKOI = fd(7, .{ .Varint = .Simple }), + .PPNLNPMEMOI = fd(8, .{ .Varint = .Simple }), + .BMBEBCGLFIF = fd(9, .{ .Varint = .Simple }), + .ICHGDINBBFN = fd(10, .{ .Varint = .Simple }), + .id = fd(11, .{ .Varint = .Simple }), + .NJDDHGADECD = fd(12, .{ .Varint = .Simple }), + .HAIIAPOODBB = fd(13, .{ .Varint = .Simple }), + }; + + pub usingnamespace protobuf.MessageMixins(@This()); +}; diff --git a/protocol/src/root.zig b/protocol/src/root.zig new file mode 100644 index 0000000..b03fa4d --- /dev/null +++ b/protocol/src/root.zig @@ -0,0 +1,1557 @@ +pub usingnamespace @import("protocol.pb.zig"); + +pub const CmdID = enum(u16) { + CmdTakeTrialActivityRewardScRsp = 2633, + CmdTakeTrialActivityRewardCsReq = 2668, + CmdTakeMonsterResearchActivityRewardCsReq = 2673, + CmdLeaveTrialActivityScRsp = 2632, + CmdGetLoginActivityCsReq = 2618, + CmdSubmitMonsterResearchActivityMaterialCsReq = 2640, + CmdStartTrialActivityScRsp = 2667, + CmdEnterTrialActivityStageScRsp = 2620, + CmdTakeLoginActivityRewardCsReq = 2629, + CmdTakeMonsterResearchActivityRewardScRsp = 2608, + CmdStartTrialActivityCsReq = 2690, + CmdGetActivityScheduleConfigScRsp = 2649, + CmdTrialActivityDataChangeScNotify = 2700, + CmdGetMonsterResearchActivityDataScRsp = 2662, + CmdTakeLoginActivityRewardScRsp = 2637, + CmdGetMonsterResearchActivityDataCsReq = 2691, + CmdSubmitMonsterResearchActivityMaterialScRsp = 2648, + CmdCurTrialActivityScNotify = 2694, + CmdLeaveTrialActivityCsReq = 2603, + CmdGetTrialActivityDataScRsp = 2688, + CmdEnterTrialActivityStageCsReq = 2610, + CmdGetActivityScheduleConfigCsReq = 2658, + CmdGetLoginActivityScRsp = 2674, + CmdGetTrialActivityDataCsReq = 2636, + CmdGetFarmStageGachaInfoCsReq = 1329, + CmdEnterAdventureScRsp = 1374, + CmdGetFarmStageGachaInfoScRsp = 1337, + CmdEnterAdventureCsReq = 1318, + CmdStartAetherDivideStageBattleCsReq = 4873, + CmdStartAetherDivideStageBattleScRsp = 4808, + CmdClearAetherDividePassiveSkillScRsp = 4862, + CmdAetherDivideLineupScNotify = 4859, + CmdAetherDivideFinishChallengeScNotify = 4847, + CmdAetherDivideSpiritInfoScNotify = 4877, + CmdGetAetherDivideInfoScRsp = 4857, + CmdSwitchAetherDivideLineUpSlotCsReq = 4840, + CmdSetAetherDivideLineUpCsReq = 4846, + CmdAetherDivideTakeChallengeRewardScRsp = 4806, + CmdAetherDivideRefreshEndlessCsReq = 4802, + CmdAetherDivideRefreshEndlessScNotify = 4809, + CmdLeaveAetherDivideSceneScRsp = 4837, + CmdClearAetherDividePassiveSkillCsReq = 4891, + CmdEnterAetherDivideSceneScRsp = 4874, + CmdGetAetherDivideChallengeInfoScRsp = 4892, + CmdAetherDivideTakeChallengeRewardCsReq = 4856, + CmdEnterAetherDivideSceneCsReq = 4818, + CmdSetAetherDivideLineUpScRsp = 4898, + CmdLeaveAetherDivideSceneCsReq = 4829, + CmdAetherDivideSkillItemScNotify = 4838, + CmdAetherDivideTainerInfoScNotify = 4861, + CmdStartAetherDivideSceneBattleScRsp = 4849, + CmdStartAetherDivideSceneBattleCsReq = 4858, + CmdEquipAetherDividePassiveSkillCsReq = 4883, + CmdSwitchAetherDivideLineUpSlotScRsp = 4848, + CmdGetAetherDivideChallengeInfoCsReq = 4824, + CmdAetherDivideRefreshEndlessScRsp = 4813, + CmdStartAetherDivideChallengeBattleScRsp = 4841, + CmdAetherDivideSpiritExpUpCsReq = 4811, + CmdAetherDivideSpiritExpUpScRsp = 4821, + CmdStartAetherDivideChallengeBattleCsReq = 4828, + CmdEquipAetherDividePassiveSkillScRsp = 4822, + CmdGetAetherDivideInfoCsReq = 4889, + CmdSaveLogisticsScRsp = 4792, + CmdTakePrestigeRewardCsReq = 4789, + CmdAlleyFundsScNotify = 4711, + CmdAlleyShopLevelScNotify = 4721, + CmdGetSaveLogisticsMapCsReq = 4738, + CmdAlleyShipmentEventEffectsScNotify = 4761, + CmdAlleyEventEffectNotify = 4764, + CmdStartAlleyEventScRsp = 4741, + CmdAlleyTakeEventRewardCsReq = 4709, + CmdAlleyGuaranteedFundsScRsp = 4713, + CmdTakePrestigeRewardScRsp = 4757, + CmdAlleyPlacingGameCsReq = 4746, + CmdLogisticsScoreRewardSyncInfoScNotify = 4780, + CmdAlleyShipUsedCountScNotify = 4759, + CmdGetSaveLogisticsMapScRsp = 4782, + CmdAlleyPlacingGameScRsp = 4798, + CmdRefreshAlleyOrderScRsp = 4762, + CmdRefreshAlleyOrderCsReq = 4791, + CmdSaveLogisticsCsReq = 4724, + CmdAlleyGuaranteedFundsCsReq = 4702, + CmdLogisticsGameCsReq = 4729, + CmdLogisticsGameScRsp = 4737, + CmdLogisticsDetonateStarSkiffScRsp = 4770, + CmdGetAlleyInfoCsReq = 4718, + CmdPrestigeLevelUpScRsp = 4708, + CmdAlleyEventChangeNotify = 4719, + CmdAlleyTakeEventRewardScRsp = 4756, + CmdPrestigeLevelUpCsReq = 4773, + CmdGetAlleyInfoScRsp = 4774, + CmdAlleyShipUnlockScNotify = 4777, + CmdAlleyOrderChangedScNotify = 4740, + CmdLogisticsDetonateStarSkiffCsReq = 4706, + CmdLogisticsInfoScNotify = 4747, + CmdStartAlleyEventCsReq = 4728, + CmdGetUpdatedArchiveDataCsReq = 2329, + CmdGetArchiveDataScRsp = 2374, + CmdGetArchiveDataCsReq = 2318, + CmdGetUpdatedArchiveDataScRsp = 2337, + CmdDressAvatarSkinScRsp = 311, + CmdRankUpAvatarCsReq = 398, + CmdRankUpAvatarScRsp = 383, + CmdMarkAvatarCsReq = 392, + CmdTakeOffRelicCsReq = 362, + CmdTakePromotionRewardCsReq = 348, + CmdLevelUpSpecialSkillTreeCsReq = 361, + CmdUnlockSpecialSkillTreeScNotify = 382, + CmdLevelUpSpecialSkillTreeScRsp = 338, + CmdUnlockSkilltreeCsReq = 358, + CmdDressAvatarSkinCsReq = 308, + CmdTakeOffRelicScRsp = 340, + CmdDressRelicAvatarCsReq = 322, + CmdDressAvatarScRsp = 364, + CmdUnlockSkilltreeScRsp = 349, + CmdPromoteAvatarScRsp = 341, + CmdAvatarExpUpCsReq = 329, + CmdAddAvatarScNotify = 346, + CmdTakeOffAvatarSkinScRsp = 377, + CmdTakePromotionRewardScRsp = 373, + CmdGetAvatarDataScRsp = 374, + CmdPromoteAvatarCsReq = 328, + CmdDressAvatarCsReq = 319, + CmdDressRelicAvatarScRsp = 391, + CmdMarkAvatarScRsp = 347, + CmdTakeOffAvatarSkinCsReq = 321, + CmdGetAvatarDataCsReq = 318, + CmdUnlockAvatarSkinScNotify = 324, + CmdTakeOffEquipmentScRsp = 357, + CmdAvatarExpUpScRsp = 337, + CmdTakeOffEquipmentCsReq = 389, + CmdSyncClientResVersionScRsp = 141, + CmdQuitBattleScRsp = 137, + CmdServerSimulateBattleFinishScNotify = 157, + CmdBattleLogReportCsReq = 164, + CmdPVEBattleResultScRsp = 174, + CmdReBattleAfterBattleLoseCsNotify = 146, + CmdSyncClientResVersionCsReq = 128, + CmdQuitBattleScNotify = 119, + CmdBattleLogReportScRsp = 189, + CmdGetCurBattleInfoScRsp = 149, + CmdPVEBattleResultCsReq = 118, + CmdQuitBattleCsReq = 129, + CmdRebattleByClientCsNotify = 198, + CmdGetCurBattleInfoCsReq = 158, + CmdGetBattleCollegeDataCsReq = 5718, + CmdStartBattleCollegeCsReq = 5737, + CmdBattleCollegeDataChangeScNotify = 5729, + CmdGetBattleCollegeDataScRsp = 5774, + CmdStartBattleCollegeScRsp = 5758, + CmdTakeBpRewardCsReq = 3037, + CmdTakeBpRewardScRsp = 3058, + CmdBattlePassInfoNotify = 3018, + CmdBuyBpLevelScRsp = 3028, + CmdTakeAllRewardScRsp = 3019, + CmdTakeAllRewardCsReq = 3041, + CmdBuyBpLevelCsReq = 3049, + CmdMatchBoxingClubOpponentCsReq = 4229, + CmdGetBoxingClubInfoCsReq = 4218, + CmdGiveUpBoxingClubChallengeScRsp = 4241, + CmdSetBoxingClubResonanceLineupCsReq = 4246, + CmdChooseBoxingClubResonanceScRsp = 4257, + CmdBoxingClubRewardScNotify = 4219, + CmdGetBoxingClubInfoScRsp = 4274, + CmdStartBoxingClubBattleScRsp = 4249, + CmdChooseBoxingClubResonanceCsReq = 4289, + CmdSetBoxingClubResonanceLineupScRsp = 4298, + CmdChooseBoxingClubStageOptionalBuffScRsp = 4222, + CmdBoxingClubChallengeUpdateScNotify = 4264, + CmdStartBoxingClubBattleCsReq = 4258, + CmdMatchBoxingClubOpponentScRsp = 4237, + CmdGiveUpBoxingClubChallengeCsReq = 4228, + CmdChooseBoxingClubStageOptionalBuffCsReq = 4283, + CmdGetChallengeGroupStatisticsScRsp = 1762, + CmdGetCurChallengeScRsp = 1789, + CmdLeaveChallengeScRsp = 1749, + CmdTakeChallengeRewardCsReq = 1783, + CmdEnterChallengeNextPhaseCsReq = 1721, + CmdChallengeSettleNotify = 1728, + CmdLeaveChallengeCsReq = 1758, + CmdStartChallengeCsReq = 1729, + CmdGetCurChallengeCsReq = 1764, + CmdRestartChallengePhaseCsReq = 1708, + CmdEnterChallengeNextPhaseScRsp = 1777, + CmdGetChallengeGroupStatisticsCsReq = 1791, + CmdStartPartialChallengeCsReq = 1740, + CmdStartChallengeScRsp = 1737, + CmdGetChallengeScRsp = 1774, + CmdGetChallengeCsReq = 1718, + CmdStartPartialChallengeScRsp = 1748, + CmdTakeChallengeRewardScRsp = 1722, + CmdChallengeLineupNotify = 1757, + CmdRestartChallengePhaseScRsp = 1711, + CmdChallengeBossPhaseSettleNotify = 1724, + CmdGetLoginChatInfoCsReq = 3983, + CmdSendMsgScRsp = 3974, + CmdRevcMsgScNotify = 3929, + CmdPrivateMsgOfflineUsersScNotify = 3937, + CmdMarkChatEmojiScRsp = 3957, + CmdGetChatFriendHistoryCsReq = 3928, + CmdGetLoginChatInfoScRsp = 3922, + CmdGetChatFriendHistoryScRsp = 3941, + CmdSendMsgCsReq = 3918, + CmdGetChatEmojiListCsReq = 3919, + CmdMarkChatEmojiCsReq = 3989, + CmdGetChatEmojiListScRsp = 3964, + CmdGetPrivateChatHistoryScRsp = 3949, + CmdGetPrivateChatHistoryCsReq = 3958, + CmdBatchMarkChatEmojiScRsp = 3998, + CmdBatchMarkChatEmojiCsReq = 3946, + CmdChessRogueRollDiceScRsp = 5471, + CmdFinishChessRogueSubStoryScRsp = 5407, + CmdChessRogueUpdateDicePassiveAccumulateValueScNotify = 5548, + CmdChessRogueUpdateAeonModifierValueScNotify = 5475, + CmdGetChessRogueNousStoryInfoScRsp = 5466, + CmdChessRogueQueryBpCsReq = 5564, + CmdChessRogueGiveUpRollScRsp = 5455, + CmdChessRogueLeaveScRsp = 5587, + CmdChessRogueSkipTeachingLevelCsReq = 5519, + CmdChessRogueUpdateDiceInfoScNotify = 5447, + CmdFinishChessRogueSubStoryCsReq = 5411, + CmdChessRogueNousGetRogueTalentInfoCsReq = 5539, + CmdChessRogueEnterCellCsReq = 5493, + CmdSyncChessRogueMainStoryFinishScNotify = 5438, + CmdChessRogueRollDiceCsReq = 5450, + CmdChessRogueCheatRollScRsp = 5567, + CmdChessRogueSelectBpCsReq = 5406, + CmdChessRogueEnterNextLayerCsReq = 5473, + CmdChessRogueCellUpdateNotify = 5412, + CmdChessRogueMoveCellNotify = 5536, + CmdChessRogueQueryAeonDimensionsScRsp = 5576, + CmdChessRogueUpdateReviveInfoScNotify = 5420, + CmdEnterChessRogueAeonRoomCsReq = 5452, + CmdChessRogueNousEditDiceCsReq = 5445, + CmdEnhanceChessRogueBuffScRsp = 5505, + CmdGetChessRogueStoryAeonTalkInfoScRsp = 5500, + CmdChessRogueSelectCellScRsp = 5442, + CmdEnhanceChessRogueBuffCsReq = 5404, + CmdChessRogueChangeyAeonDimensionNotify = 5512, + CmdChessRogueSelectBpScRsp = 5526, + CmdChessRogueLeaveCsReq = 5507, + CmdChessRogueReviveAvatarScRsp = 5470, + CmdChessRogueConfirmRollCsReq = 5415, + CmdChessRogueEnterScRsp = 5590, + CmdChessRogueLayerAccountInfoNotify = 5565, + CmdChessRogueNousEnableRogueTalentCsReq = 5531, + CmdChessRogueEnterCsReq = 5521, + CmdGetChessRogueBuffEnhanceInfoScRsp = 5421, + CmdChessRogueGoAheadCsReq = 5504, + CmdChessRogueQuitCsReq = 5549, + CmdChessRogueSkipTeachingLevelScRsp = 5489, + CmdGetChessRogueStoryAeonTalkInfoCsReq = 5456, + CmdSelectChessRogueSubStoryScRsp = 5517, + CmdChessRogueNousGetRogueTalentInfoScRsp = 5571, + CmdChessRogueStartScRsp = 5570, + CmdChessRogueGiveUpCsReq = 5524, + CmdGetChessRogueBuffEnhanceInfoCsReq = 5534, + CmdEnterChessRogueAeonRoomScRsp = 5435, + CmdSelectChessRogueNousSubStoryScRsp = 5535, + CmdChessRogueNousEditDiceScRsp = 5463, + CmdChessRogueStartCsReq = 5511, + CmdChessRogueGiveUpScRsp = 5481, + CmdSelectChessRogueSubStoryCsReq = 5427, + CmdChessRoguePickAvatarScRsp = 5441, + CmdChessRogueSelectCellCsReq = 5513, + CmdSyncChessRogueNousSubStoryScNotify = 5402, + CmdChessRogueQueryBpScRsp = 5479, + CmdChessRogueEnterCellScRsp = 5516, + CmdGetChessRogueStoryInfoScRsp = 5575, + CmdChessRogueUpdateActionPointScNotify = 5425, + CmdChessRogueNousDiceUpdateNotify = 5542, + CmdGetChessRogueNousStoryInfoCsReq = 5480, + CmdChessRogueGoAheadScRsp = 5529, + CmdChessRogueQuitScRsp = 5588, + CmdChessRogueQueryCsReq = 5458, + CmdFinishChessRogueNousSubStoryCsReq = 5579, + CmdChessRogueFinishCurRoomNotify = 5439, + CmdChessRogueUpdateBoardScNotify = 5515, + CmdSyncChessRogueNousMainStoryScNotify = 5419, + CmdChessRogueConfirmRollScRsp = 5428, + CmdChessRogueQueryScRsp = 5484, + CmdChessRogueGiveUpRollCsReq = 5448, + CmdChessRogueEnterNextLayerScRsp = 5582, + CmdFinishChessRogueNousSubStoryScRsp = 5560, + CmdChessRogueUpdateUnlockLevelScNotify = 5472, + CmdChessRogueUpdateMoneyInfoScNotify = 5594, + CmdSelectChessRogueNousSubStoryCsReq = 5566, + CmdChessRogueReviveAvatarCsReq = 5518, + CmdGetChessRogueStoryInfoCsReq = 5482, + CmdChessRogueUpdateAllowedSelectCellScNotify = 5464, + CmdChessRoguePickAvatarCsReq = 5495, + CmdChessRogueNousDiceSurfaceUnlockNotify = 5426, + CmdChessRogueCheatRollCsReq = 5444, + CmdChessRogueReRollDiceScRsp = 5555, + CmdChessRogueReRollDiceCsReq = 5424, + CmdSyncChessRogueNousValueScNotify = 5437, + CmdChessRogueNousEnableRogueTalentScRsp = 5449, + CmdChessRogueUpdateLevelBaseInfoScNotify = 5546, + CmdChessRogueQueryAeonDimensionsCsReq = 5510, + CmdChessRogueQuestFinishNotify = 5578, + CmdClockParkBattleEndScNotify = 7291, + CmdClockParkStartScriptScRsp = 7241, + CmdClockParkHandleWaitOperationCsReq = 7289, + CmdClockParkGetInfoScRsp = 7274, + CmdClockParkGetInfoCsReq = 7218, + CmdClockParkQuitScriptCsReq = 7246, + CmdClockParkHandleWaitOperationScRsp = 7257, + CmdClockParkUseBuffCsReq = 7240, + CmdClockParkGetOngoingScriptInfoCsReq = 7219, + CmdClockParkStartScriptCsReq = 7228, + CmdClockParkUseBuffScRsp = 7248, + CmdClockParkGetOngoingScriptInfoScRsp = 7264, + CmdClockParkUnlockTalentScRsp = 7249, + CmdClockParkQuitScriptScRsp = 7298, + CmdClockParkFinishScriptScNotify = 7273, + CmdClockParkUnlockTalentCsReq = 7258, + CmdContentPackageGetDataCsReq = 7519, + CmdContentPackageSyncDataScNotify = 7506, + CmdContentPackageUnlockScRsp = 7537, + CmdContentPackageUnlockCsReq = 7545, + CmdContentPackageTransferScNotify = 7520, + CmdContentPackageGetDataScRsp = 7529, + CmdDailyActiveInfoNotify = 3358, + CmdTakeApRewardScRsp = 3374, + CmdTakeAllApRewardCsReq = 3349, + CmdTakeApRewardCsReq = 3318, + CmdGetDailyActiveInfoScRsp = 3337, + CmdTakeAllApRewardScRsp = 3328, + CmdGetDailyActiveInfoCsReq = 3329, + CmdMakeMissionDrinkCsReq = 6989, + CmdDrinkMakerChallengeScRsp = 6981, + CmdGetDrinkMakerDataCsReq = 6994, + CmdDrinkMakerChallengeCsReq = 6999, + CmdMakeDrinkCsReq = 6993, + CmdEndDrinkMakerSequenceCsReq = 6983, + CmdDrinkMakerUpdateTipsNotify = 6990, + CmdMakeMissionDrinkScRsp = 6986, + CmdGetDrinkMakerDataScRsp = 6997, + CmdEndDrinkMakerSequenceScRsp = 6984, + CmdDrinkMakerDayEndScNotify = 6992, + CmdMakeDrinkScRsp = 6985, + CmdEvolveBuildQueryInfoScRsp = 7129, + CmdEvolveBuildStartStageScRsp = 7120, + CmdEvolveBuildStartStageCsReq = 7137, + CmdEvolveBuildGiveupCsReq = 7112, + CmdEvolveBuildLeaveScRsp = 7150, + CmdEvolveBuildShopAbilityDownCsReq = 7124, + CmdEvolveBuildReRandomStageCsReq = 7105, + CmdEvolveBuildStartLevelCsReq = 7106, + CmdEvolveBuildShopAbilityUpScRsp = 7131, + CmdEvolveBuildTakeExpRewardCsReq = 7148, + CmdEvolveBuildUnlockInfoNotify = 7123, + CmdEvolveBuildCoinNotify = 7139, + CmdEvolveBuildFinishScNotify = 7101, + CmdEvolveBuildGiveupScRsp = 7121, + CmdEvolveBuildShopAbilityUpCsReq = 7113, + CmdEvolveBuildShopAbilityResetCsReq = 7117, + CmdEvolveBuildTakeExpRewardScRsp = 7144, + CmdEvolveBuildQueryInfoCsReq = 7119, + CmdEvolveBuildShopAbilityDownScRsp = 7116, + CmdEvolveBuildReRandomStageScRsp = 7103, + CmdEvolveBuildStartLevelScRsp = 7145, + CmdEvolveBuildShopAbilityResetScRsp = 7149, + CmdEvolveBuildLeaveCsReq = 7109, + CmdTakeMultipleExpeditionRewardCsReq = 2562, + CmdCancelExpeditionCsReq = 2558, + CmdAcceptMultipleExpeditionScRsp = 2591, + CmdTakeMultipleExpeditionRewardScRsp = 2540, + CmdAcceptActivityExpeditionCsReq = 2564, + CmdGetExpeditionDataCsReq = 2518, + CmdCancelActivityExpeditionCsReq = 2557, + CmdAcceptExpeditionScRsp = 2537, + CmdCancelExpeditionScRsp = 2549, + CmdAcceptMultipleExpeditionCsReq = 2522, + CmdExpeditionDataChangeScNotify = 2519, + CmdTakeActivityExpeditionRewardScRsp = 2583, + CmdTakeExpeditionRewardCsReq = 2528, + CmdCancelActivityExpeditionScRsp = 2546, + CmdAcceptExpeditionCsReq = 2529, + CmdAcceptActivityExpeditionScRsp = 2589, + CmdTakeActivityExpeditionRewardCsReq = 2598, + CmdTakeExpeditionRewardScRsp = 2541, + CmdGetExpeditionDataScRsp = 2574, + CmdEnterFantasticStoryActivityStageScRsp = 4958, + CmdEnterFantasticStoryActivityStageCsReq = 4937, + CmdFinishChapterScNotify = 4929, + CmdGetFantasticStoryActivityDataCsReq = 4918, + CmdGetFantasticStoryActivityDataScRsp = 4974, + CmdFantasticStoryActivityBattleEndScNotify = 4949, + CmdFeverTimeActivityBattleEndScNotify = 7157, + CmdEnterFeverTimeActivityStageCsReq = 7152, + CmdGetFeverTimeActivityDataCsReq = 7160, + CmdGetFeverTimeActivityDataScRsp = 7156, + CmdEnterFeverTimeActivityStageScRsp = 7155, + CmdFightLeaveScNotify = 30029, + CmdFightHeartBeatCsReq = 30058, + CmdFightEnterScRsp = 30074, + CmdFightHeartBeatScRsp = 30049, + CmdFightKickOutScNotify = 30037, + CmdFightEnterCsReq = 30018, + CmdFightSessionStopScNotify = 30028, + CmdGetFightActivityDataCsReq = 3618, + CmdEnterFightActivityStageCsReq = 3637, + CmdGetFightActivityDataScRsp = 3674, + CmdEnterFightActivityStageScRsp = 3658, + CmdFightActivityDataChangeScNotify = 3629, + CmdTakeFightActivityRewardCsReq = 3649, + CmdTakeFightActivityRewardScRsp = 3628, + CmdFightMatch3DataScRsp = 30174, + CmdFightMatch3StartCountDownScNotify = 30129, + CmdFightMatch3ChatScNotify = 30189, + CmdFightMatch3SwapCsReq = 30149, + CmdFightMatch3ChatCsReq = 30119, + CmdFightMatch3TurnStartScNotify = 30137, + CmdFightMatch3SwapScRsp = 30128, + CmdFightMatch3ChatScRsp = 30164, + CmdFightMatch3ForceUpdateNotify = 30157, + CmdFightMatch3TurnEndScNotify = 30158, + CmdFightMatch3DataCsReq = 30118, + CmdFightMatch3OpponentDataScNotify = 30141, + CmdGetPlayerDetailInfoCsReq = 2929, + CmdGetFriendChallengeDetailCsReq = 2910, + CmdGetPlatformPlayerInfoScRsp = 2939, + CmdGetAssistListCsReq = 2961, + CmdSetFriendMarkCsReq = 2942, + CmdTakeAssistRewardCsReq = 2970, + CmdGetFriendBattleRecordDetailCsReq = 2968, + CmdGetFriendDevelopmentInfoScRsp = 2967, + CmdGetFriendLoginInfoScRsp = 2975, + CmdGetFriendLoginInfoCsReq = 2914, + CmdNewAssistHistoryNotify = 2906, + CmdGetAssistHistoryCsReq = 2909, + CmdGetFriendRecommendListInfoScRsp = 2948, + CmdApplyFriendScRsp = 2941, + CmdSetForbidOtherApplyFriendCsReq = 2953, + CmdSyncHandleFriendScNotify = 2957, + CmdSetFriendRemarkNameScRsp = 2908, + CmdSetFriendMarkScRsp = 2945, + CmdGetCurAssistScRsp = 2913, + CmdDeleteBlacklistScRsp = 2924, + CmdSearchPlayerScRsp = 2947, + CmdSetFriendRemarkNameCsReq = 2973, + CmdGetFriendListInfoCsReq = 2918, + CmdTakeAssistRewardScRsp = 2980, + CmdSearchPlayerCsReq = 2992, + CmdGetFriendRecommendListInfoCsReq = 2940, + CmdDeleteFriendCsReq = 2946, + CmdReportPlayerScRsp = 2921, + CmdSyncAddBlacklistScNotify = 2962, + CmdGetAssistHistoryScRsp = 2956, + CmdReportPlayerCsReq = 2911, + CmdCurAssistChangedNotify = 2923, + CmdHandleFriendCsReq = 2964, + CmdApplyFriendCsReq = 2928, + CmdSetForbidOtherApplyFriendScRsp = 2912, + CmdGetFriendChallengeLineupScRsp = 3000, + CmdGetPlayerDetailInfoScRsp = 2937, + CmdSetAssistScRsp = 2959, + CmdAddBlacklistScRsp = 2991, + CmdGetPlatformPlayerInfoCsReq = 2987, + CmdGetFriendChallengeDetailScRsp = 2920, + CmdGetFriendApplyListInfoCsReq = 2958, + CmdGetFriendAssistListCsReq = 2916, + CmdGetFriendDevelopmentInfoCsReq = 2990, + CmdGetFriendChallengeLineupCsReq = 2988, + CmdGetFriendApplyListInfoScRsp = 2949, + CmdAddBlacklistCsReq = 2922, + CmdGetFriendListInfoScRsp = 2974, + CmdGetFriendBattleRecordDetailScRsp = 2933, + CmdGetCurAssistCsReq = 2902, + CmdSetAssistCsReq = 2982, + CmdGetFriendAssistListScRsp = 2936, + CmdHandleFriendScRsp = 2989, + CmdDeleteBlacklistCsReq = 2977, + CmdDeleteFriendScRsp = 2998, + CmdSyncDeleteFriendScNotify = 2983, + CmdGetAssistListScRsp = 2938, + CmdSyncApplyFriendScNotify = 2919, + CmdDoGachaScRsp = 1937, + CmdExchangeGachaCeilingScRsp = 1941, + CmdGetGachaCeilingScRsp = 1949, + CmdGetGachaInfoScRsp = 1974, + CmdExchangeGachaCeilingCsReq = 1928, + CmdGetGachaCeilingCsReq = 1958, + CmdDoGachaCsReq = 1929, + CmdGetGachaInfoCsReq = 1918, + CmdFinishEmotionDialoguePerformanceScRsp = 6341, + CmdGetHeartDialInfoScRsp = 6374, + CmdHeartDialScriptChangeScNotify = 6319, + CmdSubmitEmotionItemScRsp = 6349, + CmdSubmitEmotionItemCsReq = 6358, + CmdHeartDialTraceScriptScRsp = 6389, + CmdHeartDialTraceScriptCsReq = 6364, + CmdGetHeartDialInfoCsReq = 6318, + CmdChangeScriptEmotionCsReq = 6329, + CmdChangeScriptEmotionScRsp = 6337, + CmdFinishEmotionDialoguePerformanceCsReq = 6328, + CmdHeliobusEnterBattleScRsp = 5873, + CmdHeliobusSnsReadCsReq = 5829, + CmdHeliobusActivityDataScRsp = 5874, + CmdHeliobusSnsReadScRsp = 5837, + CmdHeliobusSnsCommentCsReq = 5819, + CmdHeliobusActivityDataCsReq = 5818, + CmdHeliobusSnsLikeCsReq = 5828, + CmdHeliobusLineupUpdateScNotify = 5877, + CmdHeliobusUpgradeLevelCsReq = 5846, + CmdHeliobusSnsPostCsReq = 5858, + CmdHeliobusChallengeUpdateScNotify = 5821, + CmdHeliobusStartRaidScRsp = 5811, + CmdHeliobusUnlockSkillScNotify = 5883, + CmdHeliobusSnsLikeScRsp = 5841, + CmdHeliobusSnsPostScRsp = 5849, + CmdHeliobusInfoChangedScNotify = 5857, + CmdHeliobusEnterBattleCsReq = 5848, + CmdHeliobusSelectSkillScRsp = 5891, + CmdHeliobusUpgradeLevelScRsp = 5898, + CmdHeliobusStartRaidCsReq = 5808, + CmdHeliobusSnsUpdateScNotify = 5889, + CmdHeliobusSelectSkillCsReq = 5822, + CmdHeliobusSnsCommentScRsp = 5864, + CmdComposeSelectedRelicCsReq = 521, + CmdExpUpRelicScRsp = 522, + CmdComposeItemCsReq = 546, + CmdLockRelicScRsp = 562, + CmdRankUpEquipmentCsReq = 519, + CmdGetMarkItemListCsReq = 502, + CmdSyncTurnFoodNotify = 570, + CmdLockEquipmentCsReq = 558, + CmdExpUpRelicCsReq = 583, + CmdRelicAvatarRecommendScRsp = 542, + CmdMarkItemCsReq = 509, + CmdGetRelicFilterPlanScRsp = 516, + CmdComposeLimitNumUpdateNotify = 538, + CmdGetMarkItemListScRsp = 513, + CmdDeleteRelicFilterPlanCsReq = 520, + CmdAddRelicFilterPlanCsReq = 536, + CmdAddEquipmentScNotify = 524, + CmdComposeSelectedRelicScRsp = 577, + CmdUseItemScRsp = 541, + CmdDeleteRelicFilterPlanScRsp = 568, + CmdGetRecyleTimeCsReq = 592, + CmdComposeLimitNumCompleteNotify = 561, + CmdMarkRelicFilterPlanScRsp = 590, + CmdDestroyItemCsReq = 582, + CmdComposeItemScRsp = 598, + CmdDestroyItemScRsp = 559, + CmdUseItemCsReq = 528, + CmdMarkRelicFilterPlanCsReq = 533, + CmdRechargeSuccNotify = 573, + CmdAddRelicFilterPlanScRsp = 588, + CmdSellItemScRsp = 548, + CmdLockRelicCsReq = 591, + CmdGetBagScRsp = 574, + CmdExpUpEquipmentScRsp = 557, + CmdMarkItemScRsp = 556, + CmdRelicFilterPlanClearNameScNotify = 567, + CmdSetTurnFoodSwitchCsReq = 580, + CmdModifyRelicFilterPlanScRsp = 510, + CmdGetBagCsReq = 518, + CmdDiscardRelicCsReq = 539, + CmdSetTurnFoodSwitchScRsp = 523, + CmdPromoteEquipmentCsReq = 529, + CmdRelicRecommendCsReq = 575, + CmdSellItemCsReq = 540, + CmdGeneralVirtualItemDataNotify = 587, + CmdLockEquipmentScRsp = 549, + CmdExchangeHcoinScRsp = 511, + CmdModifyRelicFilterPlanCsReq = 600, + CmdGetRelicFilterPlanCsReq = 545, + CmdExchangeHcoinCsReq = 508, + CmdExpUpEquipmentCsReq = 589, + CmdCancelMarkItemNotify = 506, + CmdGetRecyleTimeScRsp = 547, + CmdPromoteEquipmentScRsp = 537, + CmdDiscardRelicScRsp = 514, + CmdRelicRecommendScRsp = 553, + CmdRelicAvatarRecommendCsReq = 512, + CmdRankUpEquipmentScRsp = 564, + CmdGetJukeboxDataScRsp = 3174, + CmdTrialBackGroundMusicScRsp = 3141, + CmdUnlockBackGroundMusicCsReq = 3158, + CmdPlayBackGroundMusicCsReq = 3129, + CmdUnlockBackGroundMusicScRsp = 3149, + CmdTrialBackGroundMusicCsReq = 3128, + CmdPlayBackGroundMusicScRsp = 3137, + CmdGetJukeboxDataCsReq = 3118, + CmdQuitLineupCsReq = 728, + CmdSwapLineupCsReq = 719, + CmdGetAllLineupDataScRsp = 773, + CmdSetLineupNameCsReq = 762, + CmdChangeLineupLeaderCsReq = 798, + CmdSetLineupNameScRsp = 740, + CmdJoinLineupCsReq = 758, + CmdChangeLineupLeaderScRsp = 783, + CmdQuitLineupScRsp = 741, + CmdReplaceLineupScRsp = 721, + CmdGetStageLineupScRsp = 774, + CmdVirtualLineupDestroyNotify = 708, + CmdSwapLineupScRsp = 764, + CmdSyncLineupNotify = 789, + CmdGetLineupAvatarDataCsReq = 757, + CmdGetLineupAvatarDataScRsp = 746, + CmdGetCurLineupDataCsReq = 729, + CmdGetCurLineupDataScRsp = 737, + CmdSwitchLineupIndexCsReq = 722, + CmdReplaceLineupCsReq = 711, + CmdGetStageLineupCsReq = 718, + CmdGetAllLineupDataCsReq = 748, + CmdExtraLineupDestroyNotify = 777, + CmdSwitchLineupIndexScRsp = 791, + CmdJoinLineupScRsp = 749, + CmdLobbySyncInfoScNotify = 7351, + CmdLobbyGetInfoScRsp = 7374, + CmdLobbyQuitScRsp = 7360, + CmdLobbyCreateScRsp = 7379, + CmdLobbyQuitCsReq = 7391, + CmdLobbyInviteScRsp = 7353, + CmdLobbyGetInfoCsReq = 7381, + CmdLobbyInviteCsReq = 7355, + CmdLobbyModifyPlayerInfoCsReq = 7362, + CmdLobbyJoinScRsp = 7395, + CmdLobbyBeginScRsp = 7370, + CmdLobbyJoinCsReq = 7356, + CmdLobbyKickOutCsReq = 7359, + CmdLobbyBeginCsReq = 7387, + CmdLobbyKickOutScRsp = 7400, + CmdLobbyInviteScNotify = 7363, + CmdLobbyCreateCsReq = 7369, + CmdLobbyModifyPlayerInfoScRsp = 7371, + CmdMarkReadMailCsReq = 829, + CmdTakeMailAttachmentScRsp = 841, + CmdNewMailScNotify = 819, + CmdMarkReadMailScRsp = 837, + CmdGetMailScRsp = 874, + CmdGetMailCsReq = 818, + CmdDelMailScRsp = 849, + CmdDelMailCsReq = 858, + CmdTakeMailAttachmentCsReq = 828, + CmdInteractChargerScRsp = 6837, + CmdDeployRotaterCsReq = 6858, + CmdEnterMapRotationRegionScRsp = 6874, + CmdGetMapRotationDataScRsp = 6857, + CmdEnterMapRotationRegionCsReq = 6818, + CmdRotateMapScRsp = 6841, + CmdGetMapRotationDataCsReq = 6889, + CmdRotateMapCsReq = 6828, + CmdRemoveRotaterCsReq = 6862, + CmdLeaveMapRotationRegionCsReq = 6819, + CmdRemoveRotaterScRsp = 6840, + CmdInteractChargerCsReq = 6829, + CmdUpdateEnergyScNotify = 6822, + CmdUpdateMapRotationDataScNotify = 6891, + CmdDeployRotaterScRsp = 6849, + CmdLeaveMapRotationRegionScNotify = 6883, + CmdResetMapRotationRegionScRsp = 6898, + CmdUpdateRotaterScNotify = 6848, + CmdLeaveMapRotationRegionScRsp = 6864, + CmdResetMapRotationRegionCsReq = 6846, + CmdStartMatchCsReq = 7319, + CmdStartMatchScRsp = 7329, + CmdGetCrossInfoCsReq = 7320, + CmdGetCrossInfoScRsp = 7312, + CmdMatchResultScNotify = 7337, + CmdCancelMatchScRsp = 7345, + CmdCancelMatchCsReq = 7306, + CmdMatchThreeSyncDataScNotify = 7437, + CmdMatchThreeGetDataScRsp = 7429, + CmdMatchThreeLevelEndCsReq = 7406, + CmdMatchThreeSetBirdPosScRsp = 7412, + CmdMatchThreeLevelEndScRsp = 7445, + CmdMatchThreeSetBirdPosCsReq = 7420, + CmdMatchThreeGetDataCsReq = 7419, + CmdFinishSectionIdCsReq = 2728, + CmdFinishPerformSectionIdCsReq = 2719, + CmdGetNpcStatusCsReq = 2729, + CmdFinishPerformSectionIdScRsp = 2764, + CmdGetNpcStatusScRsp = 2737, + CmdFinishItemIdScRsp = 2749, + CmdFinishSectionIdScRsp = 2741, + CmdFinishItemIdCsReq = 2758, + CmdGetNpcMessageGroupScRsp = 2774, + CmdGetNpcMessageGroupCsReq = 2718, + CmdGetShareDataCsReq = 4129, + CmdSubmitOrigamiItemCsReq = 4183, + CmdShareCsReq = 4118, + CmdGetMovieRacingDataScRsp = 4108, + CmdCancelCacheNotifyCsReq = 4119, + CmdSecurityReportCsReq = 4189, + CmdTriggerVoiceScRsp = 4198, + CmdSubmitOrigamiItemScRsp = 4122, + CmdGetMovieRacingDataCsReq = 4173, + CmdShareScRsp = 4174, + CmdGetGunPlayDataScRsp = 4124, + CmdTriggerVoiceCsReq = 4146, + CmdGetShareDataScRsp = 4137, + CmdTakePictureCsReq = 4158, + CmdGetGunPlayDataCsReq = 4177, + CmdUpdateMovieRacingDataCsReq = 4111, + CmdUpdateGunPlayDataCsReq = 4192, + CmdCancelCacheNotifyScRsp = 4164, + CmdTakePictureScRsp = 4149, + CmdUpdateMovieRacingDataScRsp = 4121, + CmdUpdateGunPlayDataScRsp = 4147, + CmdSecurityReportScRsp = 4157, + CmdSetMissionEventProgressCsReq = 1221, + CmdFinishCosumeItemMissionScRsp = 1298, + CmdGetMissionEventDataCsReq = 1283, + CmdGetMainMissionCustomValueScRsp = 1213, + CmdUpdateTrackMainMissionIdScRsp = 1270, + CmdStartFinishMainMissionScNotify = 1238, + CmdSyncTaskScRsp = 1228, + CmdAcceptMainMissionScRsp = 1259, + CmdAcceptMissionEventCsReq = 1262, + CmdStartFinishSubMissionScNotify = 1261, + CmdGetMainMissionCustomValueCsReq = 1202, + CmdInterruptMissionEventCsReq = 1208, + CmdFinishTalkMissionCsReq = 1229, + CmdMissionAcceptScNotify = 1209, + CmdAcceptMainMissionCsReq = 1282, + CmdAcceptMissionEventScRsp = 1240, + CmdTeleportToMissionResetPointCsReq = 1292, + CmdMissionRewardScNotify = 1258, + CmdSyncTaskCsReq = 1249, + CmdGetMissionDataCsReq = 1218, + CmdInterruptMissionEventScRsp = 1211, + CmdFinishTalkMissionScRsp = 1237, + CmdGetMissionStatusCsReq = 1248, + CmdTeleportToMissionResetPointScRsp = 1247, + CmdFinishCosumeItemMissionCsReq = 1246, + CmdGetMissionStatusScRsp = 1273, + CmdSetMissionEventProgressScRsp = 1277, + CmdDailyTaskDataScNotify = 1241, + CmdMissionGroupWarnScNotify = 1257, + CmdGetMissionEventDataScRsp = 1222, + CmdSubMissionRewardScNotify = 1224, + CmdMissionEventRewardScNotify = 1291, + CmdUpdateTrackMainMissionIdCsReq = 1206, + CmdGetMissionDataScRsp = 1274, + CmdGetMbtiReportScRsp = 7090, + CmdMonopolySelectOptionCsReq = 7064, + CmdGetMbtiReportCsReq = 7033, + CmdMonopolyLikeScRsp = 7020, + CmdMonopolyGameSettleScNotify = 7059, + CmdDailyFirstEnterMonopolyActivityScRsp = 7098, + CmdMonopolyDailySettleScNotify = 7036, + CmdMonopolyConfirmRandomScRsp = 7048, + CmdMonopolyRollDiceScRsp = 7028, + CmdMonopolyCheatDiceCsReq = 7092, + CmdMonopolyGameRaiseRatioScRsp = 7082, + CmdMonopolyScrachRaffleTicketScRsp = 7071, + CmdMonopolyGetRegionProgressScRsp = 7054, + CmdMonopolyGuessChooseCsReq = 7023, + CmdMonopolyClickCellCsReq = 7035, + CmdMonopolyGameRaiseRatioCsReq = 7038, + CmdMonopolyAcceptQuizCsReq = 7006, + CmdMonopolyLikeCsReq = 7010, + CmdDeleteSocialEventServerCacheCsReq = 7084, + CmdMonopolyGetRegionProgressCsReq = 7095, + CmdGetMonopolyDailyReportScRsp = 7052, + CmdMonopolyCellUpdateNotify = 7037, + CmdMonopolyContentUpdateScNotify = 7061, + CmdMonopolyGetRaffleTicketCsReq = 7001, + CmdMonopolyEventLoadUpdateScNotify = 7093, + CmdMonopolyLikeScNotify = 7068, + CmdMonopolyGiveUpCurContentScRsp = 7024, + CmdMonopolyGuessDrawScNotify = 7075, + CmdMonopolyRollRandomScRsp = 7022, + CmdMonopolyClickMbtiReportScRsp = 7055, + CmdMonopolyGuessBuyInformationScRsp = 7014, + CmdMonopolyClickCellScRsp = 7069, + CmdGetMonopolyMbtiReportRewardCsReq = 7026, + CmdMonopolyEventSelectFriendScRsp = 7003, + CmdMonopolySelectOptionScRsp = 7089, + CmdMonopolyEventSelectFriendCsReq = 7067, + CmdMonopolyReRollRandomScRsp = 7062, + CmdMonopolyAcceptQuizScRsp = 7070, + CmdDailyFirstEnterMonopolyActivityCsReq = 7046, + CmdMonopolyGuessChooseScRsp = 7087, + CmdMonopolyTakePhaseRewardScRsp = 7085, + CmdDeleteSocialEventServerCacheScRsp = 7076, + CmdMonopolyGiveUpCurContentCsReq = 7077, + CmdGetSocialEventServerCacheCsReq = 7094, + CmdMonopolyClickMbtiReportCsReq = 7066, + CmdMonopolyMoveCsReq = 7041, + CmdMonopolyGetDailyInitItemScRsp = 7060, + CmdMonopolyGameGachaCsReq = 7002, + CmdMonopolyBuyGoodsCsReq = 7073, + CmdMonopolyScrachRaffleTicketCsReq = 7081, + CmdMonopolyRollRandomCsReq = 7083, + CmdGetMonopolyDailyReportCsReq = 7030, + CmdMonopolyGetRafflePoolInfoScRsp = 7065, + CmdMonopolyTakePhaseRewardCsReq = 7099, + CmdMonopolySocialEventEffectScNotify = 7032, + CmdMonopolyBuyGoodsScRsp = 7008, + CmdGetMonopolyInfoScRsp = 7074, + CmdGetSocialEventServerCacheScRsp = 7078, + CmdMonopolyGetDailyInitItemCsReq = 7044, + CmdMonopolyQuizDurationChangeScNotify = 7053, + CmdMonopolyCheatDiceScRsp = 7047, + CmdGetMonopolyFriendRankingListScRsp = 7100, + CmdMonopolyReRollRandomCsReq = 7091, + CmdGetMonopolyMbtiReportRewardScRsp = 7086, + CmdMonopolyActionResultScNotify = 7029, + CmdMonopolyGameBingoFlipCardScRsp = 7056, + CmdMonopolyConditionUpdateScNotify = 7097, + CmdMonopolyGameGachaScRsp = 7013, + CmdMonopolyGetRaffleTicketScRsp = 7034, + CmdMonopolyTakeRaffleTicketRewardCsReq = 7017, + CmdMonopolyGetRafflePoolInfoCsReq = 7031, + CmdMonopolySttUpdateScNotify = 7005, + CmdMonopolyMoveScRsp = 7019, + CmdMonopolyGameCreateScNotify = 7080, + CmdMonopolyRollDiceCsReq = 7049, + CmdMonopolyTakeRaffleTicketRewardScRsp = 7051, + CmdGetMonopolyFriendRankingListCsReq = 7088, + CmdMonopolyGuessBuyInformationCsReq = 7039, + CmdMonopolyConfirmRandomCsReq = 7040, + CmdMonopolyGameBingoFlipCardCsReq = 7009, + CmdGetMonopolyInfoCsReq = 7018, + CmdMonopolyUpgradeAssetScRsp = 7021, + CmdMonopolyUpgradeAssetCsReq = 7011, + CmdMultiplayerFightGiveUpCsReq = 1058, + CmdMultiplayerFightGiveUpScRsp = 1049, + CmdMultiplayerGetFightGateCsReq = 1029, + CmdMultiplayerMatch3FinishScNotify = 1019, + CmdMultiplayerFightGameStateScRsp = 1074, + CmdMultiplayerFightGameStateCsReq = 1018, + CmdMultiplayerFightGameFinishScNotify = 1041, + CmdMultiplayerFightGameStartScNotify = 1028, + CmdMultiplayerGetFightGateScRsp = 1037, + CmdGetPlayerReturnMultiDropInfoCsReq = 4637, + CmdGetPlayerReturnMultiDropInfoScRsp = 4658, + CmdMultipleDropInfoNotify = 4649, + CmdGetMultipleDropInfoCsReq = 4618, + CmdGetMultipleDropInfoScRsp = 4674, + CmdMultipleDropInfoScNotify = 4629, + CmdSetStuffToAreaCsReq = 4358, + CmdBuyNpcStuffScRsp = 4337, + CmdUpgradeAreaScRsp = 4398, + CmdMuseumDispatchFinishedScNotify = 4321, + CmdGetStuffScNotify = 4319, + CmdUpgradeAreaStatScRsp = 4322, + CmdMuseumTakeCollectRewardCsReq = 4347, + CmdUpgradeAreaStatCsReq = 4383, + CmdMuseumRandomEventQueryCsReq = 4348, + CmdMuseumRandomEventSelectCsReq = 4308, + CmdGetMuseumInfoCsReq = 4318, + CmdGetExhibitScNotify = 4364, + CmdSetStuffToAreaScRsp = 4349, + CmdMuseumFundsChangedScNotify = 4362, + CmdRemoveStuffFromAreaCsReq = 4328, + CmdBuyNpcStuffCsReq = 4329, + CmdFinishCurTurnCsReq = 4389, + CmdUpgradeAreaCsReq = 4346, + CmdMuseumRandomEventQueryScRsp = 4373, + CmdMuseumRandomEventSelectScRsp = 4311, + CmdMuseumTargetMissionFinishNotify = 4324, + CmdMuseumTargetRewardNotify = 4392, + CmdGetMuseumInfoScRsp = 4374, + CmdMuseumTakeCollectRewardScRsp = 4361, + CmdMuseumRandomEventStartScNotify = 4340, + CmdMuseumTargetStartNotify = 4377, + CmdFinishCurTurnScRsp = 4357, + CmdMuseumInfoChangedScNotify = 4391, + CmdRemoveStuffFromAreaScRsp = 4341, + CmdTakeOfferingRewardCsReq = 6923, + CmdOfferingInfoScNotify = 6929, + CmdGetOfferingInfoCsReq = 6934, + CmdGetOfferingInfoScRsp = 6937, + CmdSubmitOfferingItemCsReq = 6933, + CmdTakeOfferingRewardScRsp = 6924, + CmdSubmitOfferingItemScRsp = 6925, + CmdSyncAcceptedPamMissionNotify = 4029, + CmdAcceptedPamMissionExpireScRsp = 4074, + CmdAcceptedPamMissionExpireCsReq = 4018, + CmdUnlockPhoneThemeScNotify = 5141, + CmdSelectChatBubbleScRsp = 5137, + CmdGetPhoneDataScRsp = 5174, + CmdUnlockChatBubbleScNotify = 5158, + CmdSelectChatBubbleCsReq = 5129, + CmdSelectPhoneThemeScRsp = 5128, + CmdSelectPhoneThemeCsReq = 5149, + CmdGetPhoneDataCsReq = 5118, + CmdSetGenderCsReq = 70, + CmdSetRedPointStatusScNotify = 17, + CmdGetBasicInfoScRsp = 45, + CmdPlayerLoginFinishScRsp = 25, + CmdSetLanguageCsReq = 47, + CmdUpdateFeatureSwitchScNotify = 12, + CmdUnlockAvatarPathScRsp = 66, + CmdGmTalkCsReq = 64, + CmdRegionStopScNotify = 62, + CmdUpdatePlayerSettingCsReq = 31, + CmdClientObjUploadCsReq = 85, + CmdAvatarPathChangedNotify = 60, + CmdSetAvatarPathCsReq = 52, + CmdPlayerLogoutCsReq = 29, + CmdStaminaInfoScNotify = 54, + CmdSetPlayerInfoScRsp = 87, + CmdGetAuthkeyCsReq = 22, + CmdSetPlayerInfoCsReq = 23, + CmdPlayerLoginFinishCsReq = 76, + CmdGateServerScNotify = 67, + CmdExchangeStaminaScRsp = 83, + CmdGetMultiPathAvatarInfoScRsp = 44, + CmdExchangeStaminaCsReq = 98, + CmdGmTalkScNotify = 41, + CmdSetGameplayBirthdayScRsp = 88, + CmdUpdatePlayerSettingScRsp = 65, + CmdGmTalkScRsp = 89, + CmdClientDownloadDataScNotify = 53, + CmdPlayerGetTokenScRsp = 49, + CmdUpdatePsnSettingsInfoCsReq = 5, + CmdGetAuthkeyScRsp = 91, + CmdServerAnnounceNotify = 38, + CmdGetLevelRewardTakenListCsReq = 8, + CmdAceAntiCheaterScRsp = 10, + CmdGetMultiPathAvatarInfoCsReq = 69, + CmdQueryProductInfoCsReq = 14, + CmdAceAntiCheaterCsReq = 100, + CmdPlayerLoginCsReq = 18, + CmdGetSecretKeyInfoCsReq = 78, + CmdPlayerLogoutScRsp = 37, + CmdDailyRefreshNotify = 16, + CmdSetGenderScRsp = 80, + CmdFeatureSwitchClosedScNotify = 3, + CmdPlayerKickOutScNotify = 19, + CmdPlayerLoginScRsp = 74, + CmdPlayerHeartBeatScRsp = 90, + CmdSetLanguageScRsp = 61, + CmdGetVideoVersionKeyCsReq = 1, + CmdGetBasicInfoCsReq = 42, + CmdAntiAddictScNotify = 40, + CmdReserveStaminaExchangeScRsp = 95, + CmdReserveStaminaExchangeCsReq = 71, + CmdSetNicknameCsReq = 48, + CmdPlayerGetTokenCsReq = 58, + CmdMonthCardRewardNotify = 20, + CmdQueryProductInfoScRsp = 75, + CmdGetSecretKeyInfoScRsp = 84, + CmdRetcodeNotify = 68, + CmdPlayerHeartBeatCsReq = 33, + CmdGetLevelRewardCsReq = 21, + CmdClientObjUploadScRsp = 93, + CmdGetLevelRewardTakenListScRsp = 11, + CmdSetAvatarPathScRsp = 35, + CmdGetLevelRewardScRsp = 77, + CmdGetVideoVersionKeyScRsp = 34, + CmdUpdatePsnSettingsInfoScRsp = 26, + CmdClientObjDownloadDataScNotify = 99, + CmdSetGameplayBirthdayCsReq = 36, + CmdSetNicknameScRsp = 73, + CmdUnlockAvatarPathCsReq = 97, + CmdSetAssistAvatarScRsp = 2846, + CmdUnlockHeadIconScNotify = 2819, + CmdSetSignatureScRsp = 2889, + CmdSetDisplayAvatarScRsp = 2849, + CmdSetDisplayAvatarCsReq = 2858, + CmdSetHeadIconScRsp = 2837, + CmdSetHeadIconCsReq = 2829, + CmdSetAssistAvatarCsReq = 2857, + CmdSetIsDisplayAvatarInfoScRsp = 2841, + CmdSetIsDisplayAvatarInfoCsReq = 2828, + CmdGetPlayerBoardDataCsReq = 2818, + CmdGetPlayerBoardDataScRsp = 2874, + CmdSetSignatureCsReq = 2864, + CmdPlayerReturnTakeRewardCsReq = 4528, + CmdPlayerReturnTakePointRewardCsReq = 4558, + CmdPlayerReturnPointChangeScNotify = 4537, + CmdPlayerReturnTakeRewardScRsp = 4541, + CmdPlayerReturnSignCsReq = 4574, + CmdPlayerReturnInfoQueryScRsp = 4564, + CmdPlayerReturnSignScRsp = 4529, + CmdPlayerReturnInfoQueryCsReq = 4519, + CmdPlayerReturnTakePointRewardScRsp = 4549, + CmdPlayerReturnForceFinishScNotify = 4589, + CmdPlayerReturnStartScNotify = 4518, + CmdFinishPlotCsReq = 1118, + CmdFinishPlotScRsp = 1174, + CmdTakeKilledPunkLordMonsterScoreScRsp = 3238, + CmdPunkLordBattleResultScNotify = 3211, + CmdTakePunkLordPointRewardCsReq = 3246, + CmdGetPunkLordMonsterDataScRsp = 3274, + CmdTakePunkLordPointRewardScRsp = 3298, + CmdGetPunkLordBattleRecordScRsp = 3202, + CmdGetKilledPunkLordMonsterDataCsReq = 3221, + CmdStartPunkLordRaidCsReq = 3229, + CmdStartPunkLordRaidScRsp = 3237, + CmdSummonPunkLordMonsterScRsp = 3241, + CmdSharePunkLordMonsterCsReq = 3258, + CmdPunkLordMonsterInfoScNotify = 3283, + CmdPunkLordRaidTimeOutScNotify = 3240, + CmdTakeKilledPunkLordMonsterScoreCsReq = 3261, + CmdGetKilledPunkLordMonsterDataScRsp = 3277, + CmdSharePunkLordMonsterScRsp = 3249, + CmdPunkLordDataChangeNotify = 3282, + CmdPunkLordMonsterKilledNotify = 3247, + CmdGetPunkLordMonsterDataCsReq = 3218, + CmdSummonPunkLordMonsterCsReq = 3228, + CmdGetPunkLordBattleRecordCsReq = 3259, + CmdGetPunkLordDataCsReq = 3222, + CmdGetPunkLordDataScRsp = 3291, + CmdGetQuestRecordScRsp = 941, + CmdFinishQuestCsReq = 964, + CmdGetQuestDataCsReq = 918, + CmdBatchGetQuestDataCsReq = 983, + CmdQuestRecordScNotify = 919, + CmdTakeQuestRewardCsReq = 929, + CmdGetQuestDataScRsp = 974, + CmdTakeQuestOptionalRewardCsReq = 957, + CmdGetQuestRecordCsReq = 928, + CmdTakeQuestOptionalRewardScRsp = 946, + CmdBatchGetQuestDataScRsp = 922, + CmdFinishQuestScRsp = 989, + CmdTakeQuestRewardScRsp = 937, + CmdGetRaidInfoCsReq = 2289, + CmdGetAllSaveRaidScRsp = 2262, + CmdDelSaveRaidScNotify = 2240, + CmdStartRaidScRsp = 2274, + CmdLeaveRaidCsReq = 2229, + CmdGetSaveRaidScRsp = 2222, + CmdChallengeRaidNotify = 2264, + CmdRaidInfoNotify = 2258, + CmdSetClientRaidTargetCountScRsp = 2298, + CmdGetRaidInfoScRsp = 2257, + CmdSetClientRaidTargetCountCsReq = 2246, + CmdRaidKickByServerScNotify = 2248, + CmdStartRaidCsReq = 2218, + CmdTakeChallengeRaidRewardScRsp = 2219, + CmdLeaveRaidScRsp = 2237, + CmdTakeChallengeRaidRewardCsReq = 2241, + CmdGetAllSaveRaidCsReq = 2291, + CmdGetSaveRaidCsReq = 2283, + CmdGetChallengeRaidInfoScRsp = 2228, + CmdGetChallengeRaidInfoCsReq = 2249, + CmdRaidCollectionDataScRsp = 6957, + CmdRaidCollectionDataCsReq = 6954, + CmdRaidCollectionDataScNotify = 6953, + CmdGetSingleRedDotParamGroupCsReq = 5958, + CmdGetAllRedDotDataCsReq = 5918, + CmdUpdateRedDotDataScRsp = 5937, + CmdUpdateRedDotDataCsReq = 5929, + CmdGetSingleRedDotParamGroupScRsp = 5949, + CmdGetAllRedDotDataScRsp = 5974, + CmdGetReplayTokenScRsp = 3574, + CmdGetPlayerReplayInfoCsReq = 3529, + CmdGetReplayTokenCsReq = 3518, + CmdGetPlayerReplayInfoScRsp = 3537, + CmdDailyFirstMeetPamCsReq = 3429, + CmdGetRndOptionCsReq = 3418, + CmdDailyFirstMeetPamScRsp = 3437, + CmdGetRndOptionScRsp = 3474, + CmdPickRogueAvatarCsReq = 1822, + CmdFinishAeonDialogueGroupScRsp = 1860, + CmdExchangeRogueRewardKeyScRsp = 1890, + CmdSyncRogueStatusScNotify = 1843, + CmdReviveRogueAvatarCsReq = 1840, + CmdSyncRogueFinishScNotify = 1883, + CmdEnableRogueTalentScRsp = 1850, + CmdGetRogueInitialScoreCsReq = 1887, + CmdSyncRogueExploreWinScNotify = 1809, + CmdEnterRogueMapRoomScRsp = 1823, + CmdEnterRogueMapRoomCsReq = 1880, + CmdStartRogueScRsp = 1837, + CmdGetRogueScoreRewardInfoCsReq = 1899, + CmdEnhanceRogueBuffCsReq = 1877, + CmdOpenRogueChestScRsp = 1868, + CmdGetRogueScoreRewardInfoScRsp = 1885, + CmdReviveRogueAvatarScRsp = 1848, + CmdSyncRogueSeasonFinishScNotify = 1856, + CmdQuitRogueCsReq = 1859, + CmdGetRogueBuffEnhanceInfoScRsp = 1821, + CmdGetRogueTalentInfoScRsp = 1866, + CmdFinishAeonDialogueGroupCsReq = 1844, + CmdOpenRogueChestCsReq = 1820, + CmdStartRogueCsReq = 1829, + CmdGetRogueInfoScRsp = 1874, + CmdGetRogueTalentInfoCsReq = 1897, + CmdSyncRogueReviveInfoScNotify = 1882, + CmdEnableRogueTalentCsReq = 1855, + CmdTakeRogueScoreRewardCsReq = 1873, + CmdSyncRogueRewardInfoScNotify = 1827, + CmdTakeRogueAeonLevelRewardCsReq = 1881, + CmdSyncRogueAeonLevelUpRewardScNotify = 1865, + CmdSyncRogueVirtualItemInfoScNotify = 1863, + CmdEnhanceRogueBuffScRsp = 1824, + CmdGetRogueInfoCsReq = 1818, + CmdQuitRogueScRsp = 1802, + CmdExchangeRogueRewardKeyCsReq = 1833, + CmdEnterRogueCsReq = 1858, + CmdSyncRogueGetItemScNotify = 1851, + CmdEnterRogueScRsp = 1849, + CmdLeaveRogueScRsp = 1841, + CmdTakeRogueScoreRewardScRsp = 1808, + CmdSyncRogueMapRoomScNotify = 1814, + CmdSyncRogueAeonScNotify = 1834, + CmdGetRogueAeonInfoCsReq = 1835, + CmdSyncRogueAreaUnlockScNotify = 1817, + CmdGetRogueBuffEnhanceInfoCsReq = 1811, + CmdSyncRoguePickAvatarInfoScNotify = 1872, + CmdGetRogueInitialScoreScRsp = 1839, + CmdLeaveRogueCsReq = 1828, + CmdTakeRogueAeonLevelRewardScRsp = 1871, + CmdPickRogueAvatarScRsp = 1891, + CmdGetRogueAeonInfoScRsp = 1869, + CmdSyncRogueCommonVirtualItemInfoScNotify = 5645, + CmdBuyRogueShopBuffScRsp = 5689, + CmdGetRogueAdventureRoomInfoScRsp = 5683, + CmdBuyRogueShopBuffCsReq = 5664, + CmdRogueDoGambleScRsp = 5669, + CmdRogueWorkbenchSelectFuncCsReq = 5644, + CmdRogueWorkbenchHandleFuncScRsp = 5651, + CmdGetRogueHandbookDataScRsp = 5670, + CmdBuyRogueShopMiracleCsReq = 5641, + CmdSyncRogueHandbookDataUpdateScNotify = 5680, + CmdPrepareRogueAdventureRoomScRsp = 5629, + CmdTakeRogueMiracleHandbookRewardScRsp = 5687, + CmdSetRogueExhibitionScRsp = 5685, + CmdCommonRogueComponentUpdateScNotify = 5625, + CmdSyncRogueCommonActionResultScNotify = 5675, + CmdExchangeRogueBuffWithMiracleScRsp = 5648, + CmdSyncRogueCommonDialogueDataScNotify = 5684, + CmdGetRogueShopMiracleInfoScRsp = 5658, + CmdCommonRogueQueryScRsp = 5668, + CmdGetRogueExhibitionScRsp = 5665, + CmdSetRogueCollectionScRsp = 5654, + CmdExchangeRogueBuffWithMiracleCsReq = 5640, + CmdGetRogueShopBuffInfoCsReq = 5649, + CmdTakeRogueEventHandbookRewardScRsp = 5614, + CmdGetRogueExhibitionCsReq = 5631, + CmdTakeRogueEventHandbookRewardCsReq = 5639, + CmdCommonRogueQueryCsReq = 5620, + CmdGetEnhanceCommonRogueBuffInfoCsReq = 5673, + CmdHandleRogueCommonPendingActionScRsp = 5610, + CmdRogueGetGambleInfoScRsp = 5652, + CmdRogueGetGambleInfoCsReq = 5630, + CmdSyncRogueAdventureRoomInfoScNotify = 5618, + CmdUpdateRogueAdventureRoomScoreCsReq = 5612, + CmdRogueDoGambleCsReq = 5635, + CmdRogueWorkbenchGetInfoCsReq = 5601, + CmdRogueNpcDisappearScRsp = 5646, + CmdGetRogueShopBuffInfoScRsp = 5628, + CmdSyncRogueCommonPendingActionScNotify = 5653, + CmdGetRogueCommonDialogueDataScRsp = 5667, + CmdStopRogueAdventureRoomCsReq = 5677, + CmdRogueWorkbenchGetInfoScRsp = 5634, + CmdUpdateRogueAdventureRoomScoreScRsp = 5642, + CmdStopRogueAdventureRoomScRsp = 5624, + CmdSyncRogueCommonDialogueOptionFinishScNotify = 5676, + CmdSelectRogueCommonDialogueOptionScRsp = 5632, + CmdRogueWorkbenchHandleFuncCsReq = 5617, + CmdGetRogueCommonDialogueDataCsReq = 5690, + CmdSelectRogueCommonDialogueOptionCsReq = 5603, + CmdFinishRogueCommonDialogueCsReq = 5694, + CmdTakeRogueMiracleHandbookRewardCsReq = 5623, + CmdPrepareRogueAdventureRoomCsReq = 5674, + CmdGetRogueHandbookDataCsReq = 5606, + CmdGetRogueCollectionScRsp = 5671, + CmdEnhanceCommonRogueBuffCsReq = 5611, + CmdBuyRogueShopMiracleScRsp = 5619, + CmdGetEnhanceCommonRogueBuffInfoScRsp = 5608, + CmdSetRogueCollectionCsReq = 5695, + CmdGetRogueCollectionCsReq = 5681, + CmdEnhanceCommonRogueBuffScRsp = 5621, + CmdCommonRogueUpdateScNotify = 5633, + CmdSetRogueExhibitionCsReq = 5699, + CmdGetRogueAdventureRoomInfoCsReq = 5698, + CmdFinishRogueCommonDialogueScRsp = 5678, + CmdRogueNpcDisappearCsReq = 5657, + CmdRogueWorkbenchSelectFuncScRsp = 5660, + CmdHandleRogueCommonPendingActionCsReq = 5700, + CmdGetRogueShopMiracleInfoCsReq = 5637, + CmdTakeRogueEndlessActivityPointRewardCsReq = 6008, + CmdTakeRogueEndlessActivityAllBonusRewardCsReq = 6004, + CmdGetRogueEndlessActivityDataCsReq = 6002, + CmdEnterRogueEndlessActivityStageScRsp = 6010, + CmdRogueEndlessActivityBattleEndScNotify = 6006, + CmdTakeRogueEndlessActivityAllBonusRewardScRsp = 6009, + CmdEnterRogueEndlessActivityStageCsReq = 6007, + CmdGetRogueEndlessActivityDataScRsp = 6005, + CmdTakeRogueEndlessActivityPointRewardScRsp = 6003, + CmdRogueModifierAddNotify = 5329, + CmdRogueModifierDelNotify = 5319, + CmdRogueModifierSelectCellCsReq = 5337, + CmdRogueModifierUpdateNotify = 5341, + CmdRogueModifierStageStartNotify = 5364, + CmdRogueModifierSelectCellScRsp = 5358, + CmdRogueTournResetPermanentTalentScRsp = 6087, + CmdRogueTournGetMiscRealTimeDataScRsp = 6042, + CmdRogueTournDifficultyCompNotify = 6100, + CmdRogueTournEnablePermanentTalentScRsp = 6012, + CmdRogueTournLeaveRogueCocoonSceneScRsp = 6022, + CmdRogueTournGetCurRogueCocoonInfoScRsp = 6061, + CmdRogueTournTakeExpRewardScRsp = 6081, + CmdRogueTournGetCurRogueCocoonInfoCsReq = 6090, + CmdRogueTournGetAllArchiveScRsp = 6034, + CmdRogueTournReEnterRogueCocoonStageScRsp = 6074, + CmdRogueTournGetArchiveRepositoryCsReq = 6043, + CmdRogueTournStartCsReq = 6031, + CmdRogueTournGetAllArchiveCsReq = 6058, + CmdRogueTournEnterScRsp = 6028, + CmdRogueTournReviveCostUpdateScNotify = 6011, + CmdRogueTournLeaveCsReq = 6068, + CmdRogueTournResetPermanentTalentCsReq = 6066, + CmdRogueTournLeaveScRsp = 6098, + CmdRogueTournWeekChallengeUpdateScNotify = 6078, + CmdRogueTournHandBookNotify = 6020, + CmdRogueTournQueryScRsp = 6018, + CmdRogueTournTakeExpRewardCsReq = 6016, + CmdRogueTournReviveAvatarScRsp = 6071, + CmdRogueTournBattleFailSettleInfoScNotify = 6027, + CmdRogueTournEnablePermanentTalentCsReq = 6057, + CmdRogueTournClearArchiveNameScNotify = 6023, + CmdRogueTournEnterLayerCsReq = 6072, + CmdRogueTournConfirmSettleCsReq = 6091, + CmdRogueTournGetSettleInfoCsReq = 6044, + CmdRogueTournEnterRogueCocoonSceneScRsp = 6035, + CmdRogueTournReEnterRogueCocoonStageCsReq = 6026, + CmdRogueTournEnterRoomCsReq = 6033, + CmdRogueTournStartScRsp = 6093, + CmdRogueTournGetPermanentTalentInfoCsReq = 6088, + CmdRogueTournGetArchiveRepositoryScRsp = 6052, + CmdRogueTournGetSettleInfoScRsp = 6013, + CmdRogueTournConfirmSettleScRsp = 6094, + CmdRogueTournQueryCsReq = 6059, + CmdRogueTournReviveAvatarCsReq = 6083, + CmdRogueTournAreaUpdateScNotify = 6021, + CmdRogueTournExpNotify = 6030, + CmdRogueTournLeaveRogueCocoonSceneCsReq = 6050, + CmdRogueTournGetMiscRealTimeDataCsReq = 6084, + CmdRogueTournGetPermanentTalentInfoScRsp = 6092, + CmdRogueTournDeleteArchiveCsReq = 6099, + CmdRogueTournLevelInfoUpdateScNotify = 6055, + CmdRogueTournEnterCsReq = 6047, + CmdRogueTournEnterLayerScRsp = 6038, + CmdRogueTournEnterRogueCocoonSceneCsReq = 6024, + CmdRogueTournEnterRoomScRsp = 6029, + CmdRogueTournRenameArchiveScRsp = 6056, + CmdRogueTournSettleScRsp = 6069, + CmdRogueTournSettleCsReq = 6039, + CmdRogueTournRenameArchiveCsReq = 6048, + CmdRogueTournDeleteArchiveScRsp = 6063, + CmdDoGachaInRollShopScRsp = 6905, + CmdGetRollShopInfoCsReq = 6914, + CmdTakeRollShopRewardCsReq = 6903, + CmdDoGachaInRollShopCsReq = 6913, + CmdGetRollShopInfoScRsp = 6917, + CmdTakeRollShopRewardScRsp = 6904, + CmdSceneEntityMoveCsReq = 1418, + CmdSceneCastSkillScRsp = 1449, + CmdEntityBindPropCsReq = 1470, + CmdEnteredSceneChangeScNotify = 1460, + CmdReturnLastTownScRsp = 1408, + CmdEnterSceneCsReq = 1425, + CmdSetClientPausedScRsp = 1487, + CmdGameplayCounterCountDownScRsp = 1485, + CmdStartTimedFarmElementScRsp = 1443, + CmdGameplayCounterRecoverScRsp = 1486, + CmdRecoverAllLineupCsReq = 1402, + CmdSpringRecoverCsReq = 1488, + CmdGroupStateChangeCsReq = 1430, + CmdDeleteSummonUnitCsReq = 1450, + CmdSceneEnterStageCsReq = 1411, + CmdSceneCastSkillCsReq = 1458, + CmdScenePlaneEventScNotify = 1417, + CmdSetGroupCustomSaveDataScRsp = 1467, + CmdEnterSectionCsReq = 1492, + CmdSpringRefreshScRsp = 1440, + CmdInteractPropScRsp = 1437, + CmdSyncEntityBuffChangeListScNotify = 1446, + CmdUpdateMechanismBarScNotify = 1433, + CmdSetGroupCustomSaveDataCsReq = 1490, + CmdSpringRecoverSingleAvatarScRsp = 1468, + CmdGetSceneMapInfoScRsp = 1481, + CmdInteractPropCsReq = 1429, + CmdSetCurInteractEntityScRsp = 1459, + CmdStartTimedCocoonStageScRsp = 1496, + CmdSceneEntityTeleportCsReq = 1484, + CmdReEnterLastElementStageScRsp = 1478, + CmdGetSpringRecoverDataScRsp = 1445, + CmdRecoverAllLineupScRsp = 1413, + CmdEnterSceneByServerScNotify = 1434, + CmdReEnterLastElementStageCsReq = 1494, + CmdGetUnlockTeleportScRsp = 1454, + CmdGroupStateChangeScNotify = 1435, + CmdRefreshTriggerByClientScRsp = 1466, + CmdStartCocoonStageScRsp = 1406, + CmdGetCurSceneInfoCsReq = 1428, + CmdGetCurSceneInfoScRsp = 1441, + CmdSceneReviveAfterRebattleCsReq = 1477, + CmdReturnLastTownCsReq = 1473, + CmdSetCurInteractEntityCsReq = 1482, + CmdDeactivateFarmElementCsReq = 1414, + CmdEnterSceneScRsp = 1401, + CmdSetSpringRecoverConfigScRsp = 1436, + CmdSceneGroupRefreshScNotify = 1405, + CmdSceneUpdatePositionVersionNotify = 1457, + CmdLastSpringRefreshTimeNotify = 1448, + CmdStartTimedFarmElementCsReq = 1463, + CmdSetClientPausedCsReq = 1423, + CmdHealPoolInfoNotify = 1410, + CmdUnlockedAreaMapScNotify = 1479, + CmdSpringRecoverScRsp = 1500, + CmdSavePointsInfoNotify = 1409, + CmdDeactivateFarmElementScRsp = 1475, + CmdSceneReviveAfterRebattleScRsp = 1424, + CmdRefreshTriggerByClientCsReq = 1497, + CmdGroupStateChangeScRsp = 1452, + CmdUpdateFloorSavedValueNotify = 1465, + CmdEnterSectionScRsp = 1447, + CmdGetEnteredSceneScRsp = 1444, + CmdRefreshTriggerByClientScNotify = 1455, + CmdGetSpringRecoverDataCsReq = 1442, + CmdActivateFarmElementCsReq = 1453, + CmdGameplayCounterCountDownCsReq = 1499, + CmdActivateFarmElementScRsp = 1412, + CmdGetSceneMapInfoCsReq = 1451, + CmdSceneCastSkillCostMpCsReq = 1498, + CmdSetSpringRecoverConfigCsReq = 1416, + CmdSyncServerSceneChangeNotify = 1471, + CmdSceneCastSkillMpUpdateScNotify = 1422, + CmdSceneCastSkillCostMpScRsp = 1483, + CmdStartCocoonStageCsReq = 1456, + CmdGetUnlockTeleportCsReq = 1495, + CmdSceneEntityMoveScRsp = 1474, + CmdGameplayCounterUpdateScNotify = 1493, + CmdSceneEnterStageScRsp = 1421, + CmdSpringRecoverSingleAvatarCsReq = 1420, + CmdSpringRefreshCsReq = 1462, + CmdUnlockTeleportNotify = 1427, + CmdGameplayCounterRecoverCsReq = 1426, + CmdEntityBindPropScRsp = 1480, + CmdDeleteSummonUnitScRsp = 1404, + CmdSceneEntityMoveScNotify = 1489, + CmdSceneEntityTeleportScRsp = 1476, + CmdStartTimedCocoonStageCsReq = 1415, + CmdGetEnteredSceneCsReq = 1469, + CmdGetAllServerPrefsDataScRsp = 6174, + CmdUpdateServerPrefsDataScRsp = 6149, + CmdGetAllServerPrefsDataCsReq = 6118, + CmdGetServerPrefsDataScRsp = 6137, + CmdUpdateServerPrefsDataCsReq = 6158, + CmdGetServerPrefsDataCsReq = 6129, + CmdTakeCityShopRewardCsReq = 1558, + CmdBuyGoodsCsReq = 1529, + CmdGetShopListCsReq = 1518, + CmdCityShopInfoScNotify = 1528, + CmdTakeCityShopRewardScRsp = 1549, + CmdBuyGoodsScRsp = 1537, + CmdGetShopListScRsp = 1574, + CmdSpaceZooMutateScRsp = 6749, + CmdSpaceZooOpCatteryScRsp = 6741, + CmdSpaceZooMutateCsReq = 6758, + CmdSpaceZooBornScRsp = 6737, + CmdSpaceZooTakeScRsp = 6783, + CmdSpaceZooExchangeItemScRsp = 6746, + CmdSpaceZooExchangeItemCsReq = 6757, + CmdSpaceZooTakeCsReq = 6798, + CmdSpaceZooDataScRsp = 6774, + CmdSpaceZooOpCatteryCsReq = 6728, + CmdSpaceZooDeleteCatScRsp = 6764, + CmdSpaceZooCatUpdateNotify = 6789, + CmdSpaceZooDeleteCatCsReq = 6719, + CmdSpaceZooDataCsReq = 6718, + CmdSpaceZooBornCsReq = 6729, + CmdGetStarFightDataCsReq = 7162, + CmdStarFightDataChangeNotify = 7166, + CmdStartStarFightLevelScRsp = 7170, + CmdGetStarFightDataScRsp = 7165, + CmdStartStarFightLevelCsReq = 7167, + CmdStoryLineTrialAvatarChangeScNotify = 6228, + CmdChangeStoryLineFinishScNotify = 6249, + CmdStoryLineInfoScNotify = 6229, + CmdGetStoryLineInfoScRsp = 6274, + CmdGetStoryLineInfoCsReq = 6218, + CmdGetStrongChallengeActivityDataScRsp = 6674, + CmdGetStrongChallengeActivityDataCsReq = 6618, + CmdEnterStrongChallengeActivityStageCsReq = 6629, + CmdEnterStrongChallengeActivityStageScRsp = 6637, + CmdStrongChallengeActivityBattleEndScNotify = 6658, + CmdSummonActivityBattleEndScNotify = 7566, + CmdEnterSummonActivityStageScRsp = 7570, + CmdEnterSummonActivityStageCsReq = 7567, + CmdGetSummonActivityDataCsReq = 7562, + CmdGetSummonActivityDataScRsp = 7565, + CmdSwordTrainingRestoreGameCsReq = 7476, + CmdGetSwordTrainingDataScRsp = 7456, + CmdSwordTrainingGiveUpGameCsReq = 7467, + CmdSwordTrainingLearnSkillScRsp = 7481, + CmdSwordTrainingSetSkillTraceScRsp = 7472, + CmdSwordTrainingExamResultConfirmCsReq = 7488, + CmdSwordTrainingDialogueSelectOptionScRsp = 7459, + CmdSwordTrainingExamResultConfirmScRsp = 7480, + CmdSwordTrainingFinishEndingHintScRsp = 7492, + CmdSwordTrainingTakeEndingRewardCsReq = 7497, + CmdSwordTrainingResumeGameCsReq = 7452, + CmdSwordTrainingStoryBattleScRsp = 7475, + CmdSwordTrainingFinishEndingHintCsReq = 7493, + CmdSwordTrainingGameSettleScNotify = 7473, + CmdSwordTrainingResumeGameScRsp = 7490, + CmdEnterSwordTrainingExamScRsp = 7460, + CmdSwordTrainingSelectEndingCsReq = 7457, + CmdSwordTrainingDailyPhaseConfirmCsReq = 7470, + CmdSwordTrainingSetSkillTraceCsReq = 7482, + CmdSwordTrainingRestoreGameScRsp = 7468, + CmdSwordTrainingTurnActionScRsp = 7487, + CmdSwordTrainingStartGameCsReq = 7474, + CmdSwordTrainingUpdateRankScRsp = 7496, + CmdSwordTrainingActionTurnSettleScNotify = 7485, + CmdSwordTrainingTurnActionCsReq = 7495, + CmdSwordTrainingGetSkillInfoScRsp = 7465, + CmdSwordTrainingStoryConfirmScRsp = 7494, + CmdSwordTrainingDialogueSelectOptionCsReq = 7471, + CmdSwordTrainingSelectEndingScRsp = 7477, + CmdSwordTrainingStoryBattleCsReq = 7478, + CmdSwordTrainingUnlockSyncScNotify = 7484, + CmdSwordTrainingRefreshPartnerAbilityCsReq = 7500, + CmdSwordTrainingDailyPhaseConfirmScRsp = 7462, + CmdEnterSwordTrainingExamCsReq = 7491, + CmdSwordTrainingGiveUpGameScRsp = 7499, + CmdSwordTrainingGetSkillInfoCsReq = 7461, + CmdSwordTrainingLearnSkillCsReq = 7463, + CmdSwordTrainingGameSyncChangeScNotify = 7469, + CmdSwordTrainingUpdateRankCsReq = 7458, + CmdSwordTrainingRefreshPartnerAbilityScRsp = 7451, + CmdSwordTrainingStartGameScRsp = 7466, + CmdSwordTrainingStoryConfirmCsReq = 7498, + CmdGetSwordTrainingDataCsReq = 7479, + CmdSwordTrainingTakeEndingRewardScRsp = 7483, + CmdPlayerSyncScNotify = 618, + CmdGetNpcTakenRewardScRsp = 2174, + CmdTakeTalkRewardScRsp = 2137, + CmdSelectInclinationTextCsReq = 2119, + CmdGetNpcTakenRewardCsReq = 2118, + CmdGetFirstTalkNpcScRsp = 2149, + CmdTakeTalkRewardCsReq = 2129, + CmdGetFirstTalkByPerformanceNpcCsReq = 2189, + CmdGetFirstTalkByPerformanceNpcScRsp = 2157, + CmdSelectInclinationTextScRsp = 2164, + CmdFinishFirstTalkNpcCsReq = 2128, + CmdFinishFirstTalkByPerformanceNpcCsReq = 2146, + CmdFinishFirstTalkByPerformanceNpcScRsp = 2198, + CmdGetFirstTalkNpcCsReq = 2158, + CmdFinishFirstTalkNpcScRsp = 2141, + CmdTelevisionActivityDataChangeScNotify = 6973, + CmdGetTelevisionActivityDataScRsp = 6977, + CmdEnterTelevisionActivityStageScRsp = 6963, + CmdEnterTelevisionActivityStageCsReq = 6965, + CmdGetTelevisionActivityDataCsReq = 6974, + CmdTelevisionActivityBattleEndScNotify = 6964, + CmdTextJoinQueryCsReq = 3829, + CmdTextJoinSaveScRsp = 3874, + CmdTextJoinQueryScRsp = 3837, + CmdTextJoinBatchSaveScRsp = 3849, + CmdTextJoinBatchSaveCsReq = 3858, + CmdTextJoinSaveCsReq = 3818, + CmdGetTrackPhotoActivityDataCsReq = 7552, + CmdSettleTrackPhotoStageCsReq = 7557, + CmdGetTrackPhotoActivityDataScRsp = 7555, + CmdQuitTrackPhotoStageCsReq = 7553, + CmdSettleTrackPhotoStageScRsp = 7560, + CmdQuitTrackPhotoStageScRsp = 7554, + CmdStartTrackPhotoStageCsReq = 7556, + CmdStartTrackPhotoStageScRsp = 7558, + CmdTakeTrainVisitorUntakenBehaviorRewardCsReq = 3719, + CmdTrainVisitorRewardSendNotify = 3749, + CmdGetTrainVisitorRegisterScRsp = 3741, + CmdTrainVisitorBehaviorFinishScRsp = 3774, + CmdGetTrainVisitorBehaviorScRsp = 3737, + CmdTrainVisitorBehaviorFinishCsReq = 3718, + CmdGetTrainVisitorRegisterCsReq = 3728, + CmdGetTrainVisitorBehaviorCsReq = 3729, + CmdShowNewSupplementVisitorScRsp = 3757, + CmdTakeTrainVisitorUntakenBehaviorRewardScRsp = 3764, + CmdTrainRefreshTimeNotify = 3758, + CmdShowNewSupplementVisitorCsReq = 3789, + CmdTravelBrochureSetCustomValueScRsp = 6422, + CmdTravelBrochureSetPageDescStatusScRsp = 6462, + CmdTravelBrochureUpdatePasterPosCsReq = 6489, + CmdTravelBrochureSelectMessageScRsp = 6449, + CmdTravelBrochurePageResetCsReq = 6440, + CmdTravelBrochureGetDataCsReq = 6418, + CmdTravelBrochureGetPasterScNotify = 6446, + CmdTravelBrochureApplyPasterListScRsp = 6408, + CmdTravelBrochureRemovePasterScRsp = 6464, + CmdTravelBrochureGetDataScRsp = 6474, + CmdTravelBrochureUpdatePasterPosScRsp = 6457, + CmdTravelBrochureRemovePasterCsReq = 6419, + CmdTravelBrochurePageUnlockScNotify = 6429, + CmdTravelBrochureApplyPasterScRsp = 6441, + CmdTravelBrochureSetCustomValueCsReq = 6483, + CmdTravelBrochureApplyPasterCsReq = 6428, + CmdTravelBrochureSetPageDescStatusCsReq = 6491, + CmdTravelBrochurePageResetScRsp = 6448, + CmdTravelBrochureSelectMessageCsReq = 6458, + CmdTravelBrochureApplyPasterListCsReq = 6473, + CmdQuitTreasureDungeonCsReq = 4411, + CmdFightTreasureDungeonMonsterCsReq = 4491, + CmdInteractTreasureDungeonGridCsReq = 4440, + CmdTreasureDungeonDataScNotify = 4418, + CmdOpenTreasureDungeonGridScRsp = 4422, + CmdGetTreasureDungeonActivityDataScRsp = 4457, + CmdUseTreasureDungeonItemScRsp = 4408, + CmdQuitTreasureDungeonScRsp = 4421, + CmdEnterTreasureDungeonCsReq = 4446, + CmdOpenTreasureDungeonGridCsReq = 4483, + CmdUseTreasureDungeonItemCsReq = 4473, + CmdGetTreasureDungeonActivityDataCsReq = 4489, + CmdFightTreasureDungeonMonsterScRsp = 4462, + CmdTreasureDungeonFinishScNotify = 4474, + CmdEnterTreasureDungeonScRsp = 4498, + CmdInteractTreasureDungeonGridScRsp = 4448, + CmdUnlockTutorialScRsp = 1649, + CmdUnlockTutorialGuideCsReq = 1628, + CmdFinishTutorialCsReq = 1619, + CmdGetTutorialGuideScRsp = 1637, + CmdGetTutorialCsReq = 1618, + CmdFinishTutorialGuideCsReq = 1689, + CmdGetTutorialGuideCsReq = 1629, + CmdUnlockTutorialCsReq = 1658, + CmdFinishTutorialGuideScRsp = 1657, + CmdGetTutorialScRsp = 1674, + CmdFinishTutorialScRsp = 1664, + CmdUnlockTutorialGuideScRsp = 1641, + CmdTakeChapterRewardScRsp = 419, + CmdSetCurWaypointCsReq = 429, + CmdSetCurWaypointScRsp = 437, + CmdGetChapterScRsp = 449, + CmdGetWaypointScRsp = 474, + CmdGetChapterCsReq = 458, + CmdWaypointShowNewCsNotify = 428, + CmdTakeChapterRewardCsReq = 441, + CmdGetWaypointCsReq = 418, + CmdGetWolfBroGameDataScRsp = 6564, + CmdStartWolfBroGameCsReq = 6518, + CmdGetWolfBroGameDataCsReq = 6519, + CmdWolfBroGameDataChangeScNotify = 6589, + CmdRestoreWolfBroGameArchiveCsReq = 6558, + CmdWolfBroGameActivateBulletScRsp = 6591, + CmdStartWolfBroGameScRsp = 6574, + CmdQuitWolfBroGameScRsp = 6541, + CmdWolfBroGameUseBulletScRsp = 6546, + CmdWolfBroGameExplodeMonsterScRsp = 6540, + CmdWolfBroGamePickupBulletCsReq = 6598, + CmdWolfBroGameExplodeMonsterCsReq = 6562, + CmdArchiveWolfBroGameScRsp = 6537, + CmdWolfBroGamePickupBulletScRsp = 6583, + CmdWolfBroGameUseBulletCsReq = 6557, + CmdQuitWolfBroGameCsReq = 6528, + CmdArchiveWolfBroGameCsReq = 6529, + CmdWolfBroGameActivateBulletCsReq = 6522, + CmdRestoreWolfBroGameArchiveScRsp = 6549, + _, +};