By Shauren

structs_601_18179.h

    class AccountObjectSetCheats
    {
        bool AutoBattle = false;
        AccountobjectSetCheats Type;
        int8 SlotLockCheat = 0;
    };

    class AccountObjectGetProfile
    {
        std::string Filename;
    };

    class AccountObjectSetProfile
    {
        Data Profile;
    };

    class CliCharacterObjectTest
    {
        int32 Ping = 0;
    };

    class CliChatJoinChannel
    {
        std::string Password;
        std::string ChannelName;
        bool CreateVoiceSession = false;
        int32 ChatChannelId = 0;
        bool Internal = false;
    };

    class CliChatLeaveChannel
    {
        int32 ZoneChannelID = 0;
        std::string ChannelName;
    };

    class CliChatGMChat
    {
        std::string Source;
        std::string Arguments;
        std::string Dest;
        ObjectGuid Target;
    };

    class CliChatReportIgnored
    {
        ObjectGuid IgnoredGUID;
        uint8 Reason = 0;
    };

    class CliChatReportFiltered
    {
        ObjectGuid FilteredSenderGUID;
    };

    class CliStructAddonPrefix
    {
        std::string Name;
    };

    class CliChatRegisterAddonPrefixes
    {
        std::vector<CliStructAddonPrefix> Prefixes;
    };

    class CliChatMessageChannel
    {
        int32 Language = 0;
        std::string Text;
        std::string Target;
    };

    class CliChatAddonMessageChannel
    {
        std::string Text;
        std::string Target;
        std::string Prefix;
    };

    class CliChatMessageWhisper
    {
        std::string Target;
        std::string Text;
        int32 Language = 0;
    };

    class CliChatAddonMessageWhisper
    {
        std::string Prefix;
        std::string Target;
        std::string Text;
    };

    class CliChatMessageGuild
    {
        int32 Language = 0;
        std::string Text;
    };

    class CliChatAddonMessageGuild
    {
        std::string Prefix;
        std::string Text;
    };

    class CliChatMessageOfficer
    {
        int32 Language = 0;
        std::string Text;
    };

    class CliChatAddonMessageOfficer
    {
        std::string Text;
        std::string Prefix;
    };

    class CliChatMessageAfk
    {
        std::string Text;
    };

    class CliChatMessageDnd
    {
        std::string Text;
    };

    class CliChatChannelList
    {
        std::string ChannelName;
    };

    class CliChatChannelDisplayList
    {
        std::string ChannelName;
    };

    class CliChatChannelPassword
    {
        std::string Name;
        std::string ChannelName;
    };

    class CliChatChannelSetOwner
    {
        std::string Name;
        std::string ChannelName;
    };

    class CliChatChannelOwner
    {
        std::string ChannelName;
    };

    class CliChatChannelModerate
    {
        std::string ChannelName;
    };

    class CliChatChannelModerator
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelUnmoderator
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelMute
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelUnmute
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelInvite
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelKick
    {
        std::string Name;
        std::string ChannelName;
    };

    class CliChatChannelBan
    {
        std::string Name;
        std::string ChannelName;
    };

    class CliChatChannelUnban
    {
        std::string Name;
        std::string ChannelName;
    };

    class CliChatChannelAnnouncements
    {
        std::string ChannelName;
    };

    class CliChatChannelSilenceVoice
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelUnsilenceVoice
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelSilenceAll
    {
        std::string Name;
        std::string ChannelName;
    };

    class CliChatChannelUnsilenceAll
    {
        std::string ChannelName;
        std::string Name;
    };

    class CliChatChannelVoiceOn
    {
        std::string ChannelName;
    };

    class CliChatChannelVoiceOff
    {
        std::string ChannelName;
    };

    class CliChatChannelDeclineInvite
    {
        std::string ChannelName;
    };

    class CliChatMessageSay
    {
        std::string Text;
        int32 Language = 0;
    };

    class CliChatMessageEmote
    {
        std::string Text;
    };

    class CliChatMessageYell
    {
        std::string Text;
        int32 Language = 0;
    };

    class CliChatMessageParty
    {
        std::string Text;
        int32 Language = 0;
    };

    class CliChatAddonMessageParty
    {
        std::string Prefix;
        std::string Text;
    };

    class CliChatMessageRaid
    {
        std::string Text;
        int32 Language = 0;
    };

    class CliChatAddonMessageRaid
    {
        std::string Text;
        std::string Prefix;
    };

    class CliChatMessageInstanceChat
    {
        int32 Language = 0;
        std::string Text;
    };

    class CliChatAddonMessageInstanceChat
    {
        std::string Prefix;
        std::string Text;
    };

    class CliChatMessageRaidWarning
    {
        int32 Language = 0;
        std::string Text;
    };

    class VirtualRealmNameInfo
    {
        bool IsLocal = false;
        std::string RealmNameActual;
        std::string RealmNameNormalized;
    };

    class VirtualRealmInfo
    {
        uint32 RealmAddress = 0;
        VirtualRealmNameInfo RealmNameInfo;
    };

    class RaceClassAvailability
    {
        uint8 RaceOrClassID = 0;
        uint8 RequiredExpansion = 0;
    };

    class AvailableCharacterTemplateClass
    {
        uint8 ClassID = 0;
        uint8 FactionGroup = 0;
    };

    class AvailableCharacterTemplateSet
    {
        uint32 TemplateSetID = 0;
        std::string Name;
        std::string Description;
        std::vector<AvailableCharacterTemplateClass> Classes;
    };

    class AuthSuccessInfo
    {
        uint32 VirtualRealmAddress = 0;
        std::vector<VirtualRealmInfo> VirtualRealms;
        uint32 TimeRemain = 0;
        uint32 TimeOptions = 0;
        uint32 TimeRested = 0;
        uint8 ActiveExpansionLevel = 0;
        uint8 AccountExpansionLevel = 0;
        bool IsExpansionTrial = false;
        uint32 TimeSecondsUntilPCKick = 0;
        std::vector<RaceClassAvailability> AvailableRaces;
        std::vector<RaceClassAvailability> AvailableClasses;
        std::vector<AvailableCharacterTemplateSet> Templates;
        bool ForceCharacterTemplate = false;
        Optional<uint16> NumPlayersHorde;
        Optional<uint16> NumPlayersAlliance;
        bool IsVeteranTrial = false;
        uint32 CurrencyID = 0;
    };

    class ClientSetVeteranTrial
    {
        bool IsVeteranTrial = false;
    };

    class AuthWaitInfo
    {
        uint32 WaitCount = 0;
        bool HasFCM = false;
    };

    class ClientAuthResponse
    {
        Optional<AuthWaitInfo> WaitInfo;
        uint8 Result = 0;
        Optional<AuthSuccessInfo> SuccessInfo;
    };

    class ClientWaitQueueUpdate
    {
        AuthWaitInfo WaitInfo;
    };

    class AllAchievements
    {
        std::vector<EarnedAchievement> Earned;
        std::vector<CriteriaProgress> Progress;
    };

    class ClientAllAchievementData
    {
        AllAchievements Data;
    };

    class ClientAllAccountCriteria
    {
        std::vector<CriteriaProgress> Progress;
    };

    class ClientRespondInspectAchievements
    {
        ObjectGuid Player;
        AllAchievements Data;
    };

    class ClientSetupCurrencyRecord
    {
        int32 Type = 0;
        int32 Quantity = 0;
        Optional<int32> WeeklyQuantity;
        Optional<int32> MaxWeeklyQuantity;
        Optional<int32> TrackedQuantity;
        uint8 Flags = 0;
    };

    class ClientSetupCurrency
    {
        std::vector<ClientSetupCurrencyRecord> Data;
    };

    class ClientSetCurrency
    {
        bool SuppressChatLog = false;
        Optional<int32> TrackedQuantity;
        int32 Quantity = 0;
        uint32 Flags = 0;
        int32 Type = 0;
        Optional<int32> WeeklyQuantity;
    };

    class ClientMessageBox
    {
        Data Text;
    };

    class ClientWardenData
    {
        Data Packet;
    };

    class ClientPhaseShiftChange
    {
        ObjectGuid Client;
        Data PreloadMapIDs;
        PhaseShiftData PhaseShift;
        Data UiWorldMapAreaIDSwaps;
        Data VisibleMapIDs;
    };

    class ClientMountResult
    {
        uint32 Result = 0;
    };

    class ClientDismountResult
    {
        uint32 Result = 0;
    };

    class ClientBindPointUpdate
    {
        uint32 BindMapID = 0;
        Vector3 BindPosition;
        uint32 BindAreaID = 0;
    };

    class ClientPlayerBound
    {
        ObjectGuid BinderID;
        uint32 AreaID = 0;
    };

    class ClientResurrectRequest
    {
        ObjectGuid ResurrectOffererGUID;
        bool Sickness = false;
        uint32 ResurrectOffererVirtualRealmAddress = 0;
        std::string Name;
        uint32 PetNumber = 0;
        bool UseTimer = false;
        int32 SpellID = 0;
    };

    class ClientInitialSetup
    {
        uint8 ServerExpansionTier = 0;
        uint8 ServerExpansionLevel = 0;
        time_t RaidOrigin = time_t(0);
        std::vector<uint8> QuestsCompleted;
        int32 ServerRegionID = 0;
    };

    class UnwrappedTradeItem
    {
        ItemInstance Item;
        int32 EnchantID = 0;
        int32 OnUseEnchantmentID = 0;
        ObjectGuid Creator;
        int32 Charges = 0;
        bool Lock = false;
        uint32 MaxDurability = 0;
        uint32 Durability = 0;
        int32 SocketEnchant[3] = { };
    };

    class TradeItem
    {
        uint8 Slot = 0;
        int32 EntryID = 0;
        int32 StackCount = 0;
        ObjectGuid GiftCreator;
        Optional<UnwrappedTradeItem> Unwrapped;
    };

    class ClientTradeUpdated
    {
        uint64 Gold = 0;
        uint32 CurrentStateIndex = 0;
        uint8 WhichPlayer = 0;
        uint32 ClientStateIndex = 0;
        std::vector<TradeItem> Items;
        int32 CurrencyType = 0;
        uint32 ID = 0;
        int32 ProposedEnchantment = 0;
        int32 CurrencyQuantity = 0;
    };

    class ClientTradeStatus
    {
        TradeStatus Status;
        uint8 TradeSlot = 0;
        ObjectGuid Partner;
        int32 CurrencyType = 0;
        int32 CurrencyQuantity = 0;
        bool FailureForYou = false;
        int32 BagResult = 0;
        int32 ItemID = 0;
        uint32 ID = 0;
        bool PartnerIsSameBnetAccount = false;
    };

    class ClientCharacterListItem
    {
        uint32 DisplayID = 0;
        uint32 DisplayEnchantID = 0;
        uint8 InvType = 0;
    };

    class ClientCharacterListEntry
    {
        ObjectGuid Guid;
        std::string Name;
        uint8 ListPosition = 0;
        uint8 RaceID = 0;
        uint8 ClassID = 0;
        uint8 SexID = 0;
        uint8 SkinID = 0;
        uint8 FaceID = 0;
        uint8 HairStyle = 0;
        uint8 HairColor = 0;
        uint8 FacialHairStyle = 0;
        uint8 ExperienceLevel = 0;
        int32 ZoneID = 0;
        int32 MapID = 0;
        Vector3 PreloadPos;
        ObjectGuid GuildGUID;
        uint32 Flags = 0;
        uint32 Flags2 = 0;
        uint32 Flags3 = 0;
        bool FirstLogin = false;
        uint32 PetCreatureDisplayID = 0;
        uint32 PetExperienceLevel = 0;
        uint32 PetCreatureFamilyID = 0;
        bool BoostInProgress = false;
        int32 ProfessionIDs[2] = { };
        ClientCharacterListItem InventoryItems[23] = { };
    };

    class ClientRestrictedFactionChangeRule
    {
        int32 Mask = 0;
        uint8 RaceID = 0;
    };

    class ClientEnumCharactersResult
    {
        std::vector<ClientCharacterListEntry> Characters;
        bool Success = false;
        std::vector<ClientRestrictedFactionChangeRule> FactionChangeRestrictions;
        bool IsDeletedCharacters = false;
    };

    class ClientGenerateRandomCharacterNameResult
    {
        std::string Name;
        bool Success = false;
    };

    class ResearchHistory
    {
        int32 ProjectID = 0;
        time_t FirstCompleted = time_t(0);
        int32 CompletionCount = 0;
    };

    class ClientSetupResearchHistory
    {
        std::vector<ResearchHistory> History;
    };

    class ClientResearchComplete
    {
        ResearchHistory Research;
    };

    class ClientArchaeologySurveryCast
    {
        int32 ResearchBranchID = 0;
        bool SuccessfulFind = false;
        uint32 NumFindsCompleted = 0;
        uint32 TotalFinds = 0;
    };

    class ClientPetSlotUpdated
    {
        int32 PetSlotA = 0;
        int32 PetNumberB = 0;
        int32 PetNumberA = 0;
        int32 PetSlotB = 0;
    };

    class ClientPetMode
    {
        ObjectGuid PetGUID;
        uint32 PetMode = 0;
    };

    class ClientUpdateServerPlayerPosition
    {
        Vector3 Position;
    };

    class ClientRoleChangedInform
    {
        ObjectGuid ChangedUnit;
        ObjectGuid From;
        uint32 NewRole = 0;
        uint32 OldRole = 0;
        uint8 PartyIndex = 0;
    };

    class ClientRolePollInform
    {
        ObjectGuid From;
        uint8 PartyIndex = 0;
    };

    class ClientSummonRaidMemberValidateReason
    {
        ObjectGuid Member;
        int32 ReasonCode = 0;
    };

    class ClientSummonRaidMemberValidateFailed
    {
        std::vector<ClientSummonRaidMemberValidateReason> Members;
    };

    class ClientBattlefieldStatus_Header
    {
        CliRideTicket Ticket;
        uint64 QueueID = 0;
        uint8 RangeMin = 0;
        uint8 RangeMax = 0;
        uint8 TeamSize = 0;
        uint32 InstanceID = 0;
        bool RegisteredMatch = false;
        bool TournamentRules = false;
    };

    class ClientBattlefieldStatus_NeedConfirmation
    {
        uint32 Timeout = 0;
        uint32 Mapid = 0;
        ClientBattlefieldStatus_Header Hdr;
        uint8 Role = 0;
    };

    class ClientBattlefieldStatus_Active
    {
        ClientBattlefieldStatus_Header Hdr;
        uint32 ShutdownTimer = 0;
        uint8 ArenaFaction = 0;
        bool LeftEarly = false;
        uint32 StartTimer = 0;
        uint32 Mapid = 0;
    };

    class ClientBattlefieldStatus_Queued
    {
        uint32 AverageWaitTime = 0;
        ClientBattlefieldStatus_Header Hdr;
        bool AsGroup = false;
        bool SuspendedQueue = false;
        bool EligibleForMatchmaking = false;
        uint32 WaitTime = 0;
    };

    class ClientBattlefieldStatus_None
    {
        CliRideTicket Ticket;
    };

    class ClientBattlefieldStatus_Failed
    {
        uint64 QueueID = 0;
        ObjectGuid ClientID;
        int32 Reason = 0;
        CliRideTicket Ticket;
    };

    class ClientBattlefieldList
    {
        uint8 MaxLevel = 0;
        bool PvpAnywhere = false;
        ObjectGuid BattlemasterGuid;
        bool IsRandomBG = false;
        uint8 MinLevel = 0;
        bool HasHolidayWinToday = false;
        int32 BattlemasterListID = 0;
        bool HasRandomWinToday = false;
        std::vector<int32> Battlefields;
    };

    class BattlegroundPlayerPosition
    {
        ObjectGuid Guid;
        Vector2 Pos;
        int8 IconID = 0;
        int8 ArenaSlot = 0;
    };

    class ClientBattlegroundPlayerPositions
    {
        std::vector<BattlegroundPlayerPosition> FlagCarriers;
    };

    class BattlegroundCapturePointInfo
    {
        ObjectGuid Guid;
        Vector2 Pos;
        int8 State = 0;
        time_t CaptureTime = time_t(0);
        uint32 CaptureTotalDuration = 0;
    };

    class ClientUpdateCapturePoint
    {
        BattlegroundCapturePointInfo CapturePointInfo;
    };

    class ClientCapturePointRemoved
    {
        ObjectGuid CapturePointGUID;
    };

    class ClientBattlegroundPlayerJoined
    {
        ObjectGuid Guid;
    };

    class ClientBattlegroundPlayerLeft
    {
        ObjectGuid Guid;
    };

    class ClientBFMgrEntryInvite
    {
        int32 AreaID = 0;
        time_t ExpireTime = time_t(0);
        uint64 QueueID = 0;
    };

    class ClientBFMgrEntering
    {
        bool Relocated = false;
        bool ClearedAFK = false;
        bool OnOffense = false;
        uint64 QueueID = 0;
    };

    class ClientBFMgrQueueRequestResponse
    {
        int8 Result = 0;
        int8 BattleState = 0;
        ObjectGuid FailedPlayerGUID;
        uint64 QueueID = 0;
        bool LoggingIn = false;
        int32 AreaID = 0;
    };

    class ClientBFMgrEjectPending
    {
        uint64 QueueID = 0;
        bool Remote = false;
    };

    class ClientBFMgrEjected
    {
        uint64 QueueID = 0;
        bool Relocated = false;
        int8 Reason = 0;
        int8 BattleState = 0;
    };

    class ClientBFMgrQueueInvite
    {
        uint64 QueueID = 0;
        uint32 InstanceID = 0;
        uint32 Timeout = 0;
        int32 MapID = 0;
        int32 MaxLevel = 0;
        int32 MinLevel = 0;
        int8 BattleState = 0;
        int8 Index = 0;
    };

    class ClientBFMgrStateChanged
    {
        uint64 QueueID = 0;
        int32 State = 0;
    };

    class ClientRequestCemeteryListResponse
    {
        bool IsGossipTriggered = false;
        std::vector<uint32> CemeteryID;
    };

    class ClientCheckWargameEntry
    {
        uint64 QueueID = 0;
        ObjectGuid OpposingPartyBnetAccountID;
        ServerSpec OpposingPartyUserServer;
        ObjectGuid OpposingPartyMember;
        time_t TimeoutSeconds = time_t(0);
        bool TournamentRules = false;
    };

    class ClientShowRatings
    {
        int32 PersonalRating[6] = { };
        float GdfRating[6] = 0.0f;
        float GdfVariance[6] = 0.0f;
    };

    class ClientDBReply
    {
        uint32 TableHash = 0;
        uint32 Timestamp = 0;
        int32 RecordID = 0;
        Data Data;
    };

    class ClientHotfixNotify
    {
        uint32 TableHash = 0;
        uint32 Timestamp = 0;
        int32 RecordID = 0;
    };

    class HotfixNotify
    {
        uint32 TableHash = 0;
        int32 RecordID = 0;
        uint32 Timestamp = 0;
    };

    class ClientHotfixNotifyBlob
    {
        std::vector<HotfixNotify> Hotfixes;
    };

    class ClientBattlefieldStatus_WaitForGroups
    {
        uint32 Timeout = 0;
        ClientBattlefieldStatus_Header Hdr;
        uint32 Mapid = 0;
        uint8 TotalPlayers[2] = { };
        uint8 AwaitingPlayers[2] = { };
    };

    class ClientBracketInfo
    {
        int32 PersonalRating = 0;
        int32 Ranking = 0;
        int32 SeasonPlayed = 0;
        int32 SeasonWon = 0;
        int32 WeeklyPlayed = 0;
        int32 WeeklyWon = 0;
        int32 BestWeeklyRating = 0;
        int32 BestSeasonRating = 0;
    };

    class ClientRatedBattlefieldInfo
    {
        ClientBracketInfo Bracket[6] = { };
    };

    class ClientAverageItemLevelInform
    {
        float AvgItemLevel = 0.0f;
    };

    class ClientPetAdded
    {
        std::string Name;
        int32 CreatureID = 0;
        int32 Level = 0;
        uint32 PetNumber = 0;
        int32 DisplayID = 0;
        uint8 Flags = 0;
        int32 PetSlot = 0;
    };

    class ClientPetStableInfo
    {
        uint32 PetSlot = 0;
        uint32 PetNumber = 0;
        uint32 CreatureID = 0;
        uint32 DisplayID = 0;
        uint32 ExperienceLevel = 0;
        std::string PetName;
        uint8 PetFlags = 0;
    };

    class ClientPetStableList
    {
        std::vector<ClientPetStableInfo> Pets;
        ObjectGuid StableMaster;
    };

    class ClientPetStableResult
    {
        uint8 Result = 0;
    };

    class ClientNewWorld
    {
        int32 MapID = 0;
        uint32 Reason = 0;
        float Facing = 0.0f;
        Vector3 Position;
    };

    class ClientLoginVerifyWorld
    {
        float Facing = 0.0f;
        int32 MapID = 0;
        uint32 Reason = 0;
        Vector3 Position;
    };

    class ClientNotifyMoney
    {
        uint64 Money = 0;
    };

    class ClientItemPurchaseRefundItem
    {
        int32 ItemID = 0;
        int32 ItemCount = 0;
    };

    class ClientItemPurchaseRefundCurrency
    {
        int32 CurrencyID = 0;
        int32 CurrencyCount = 0;
    };

    class ClientItemPurchaseContents
    {
        uint32 Money = 0;
        ClientItemPurchaseRefundItem Items[5] = { };
        ClientItemPurchaseRefundCurrency Currencies[5] = { };
    };

    class ClientItemPurchaseRefundResult
    {
        uint8 Result = 0;
        ObjectGuid ItemGUID;
        Optional<ClientItemPurchaseContents> Contents;
    };

    class ClientSetItemPurchaseData
    {
        uint32 PurchaseTime = 0;
        uint32 Flags = 0;
        ClientItemPurchaseContents Contents;
        ObjectGuid ItemGUID;
    };

    class ClientItemExpirePurchaseRefund
    {
        ObjectGuid ItemGUID;
    };

    class ClientInspectHonorStats
    {
        ObjectGuid PlayerGUID;
        uint32 LifetimeHK = 0;
        uint16 YesterdayHK = 0;
        uint16 TodayHK = 0;
        uint8 LifetimeMaxRank = 0;
    };

    class ClientPVPLogData_RatingData
    {
        int32 Prematch[2] = { };
        int32 Postmatch[2] = { };
        int32 PrematchMMR[2] = { };
    };

    class ClientPVPLogData_Honor
    {
        uint32 HonorKills = 0;
        uint32 Deaths = 0;
        uint32 ContributionPoints = 0;
    };

    class ClientPVPLogData_Player
    {
        ObjectGuid PlayerGUID;
        uint32 Kills = 0;
        uint8 Faction = 0;
        bool IsInWorld = false;
        Optional<ClientPVPLogData_Honor> Honor;
        uint32 DamageDone = 0;
        uint32 HealingDone = 0;
        Optional<uint32> PreMatchRating;
        Optional<int32> RatingChange;
        Optional<uint32> PreMatchMMR;
        Optional<int32> MmrChange;
        std::vector<int32> Stats;
        int32 PrimaryTalentTree = 0;
    };

    class ClientPVPLogData
    {
        Optional<uint8> Winner;
        std::vector<ClientPVPLogData_Player> Players;
        Optional<ClientPVPLogData_RatingData> Ratings;
        int8 PlayerCount[2] = { };
    };

    class ClientWargameRequestSuccessfullySentToOpponent
    {
        ObjectGuid Opponent;
    };

    class ClientDisplayGameError
    {
        Optional<int32> Arg2;
        Optional<int32> Arg;
        uint32 Error = 0;
    };

    class ClientPVPOptionsEnabled
    {
        bool WargameArenas = false;
        bool RatedArenas = false;
        bool WargameBattlegrounds = false;
        bool ArenaSkirmish = false;
        bool PugBattlegrounds = false;
        bool RatedBattlegrounds = false;
    };

    class ClientSetMaxWeeklyQuantity
    {
        int32 MaxWeeklyQuantity = 0;
        int32 Type = 0;
    };

    class ClientPetitionAlreadySigned
    {
        ObjectGuid SignerGUID;
    };

    class ClientRaidMarkersChanged
    {
        uint32 ActiveMarkers = 0;
        uint8 PartyIndex = 0;
        std::vector<CliRaidMarkerData> MarkerData;
    };

    class ClientStreamingMovies
    {
        std::vector<uint16> MovieIDs;
    };

    class ClientTimeSyncRequest
    {
        uint32 SequenceIndex = 0;
    };

    class ClientTimeAdjustment
    {
        uint32 SequenceIndex = 0;
        float TimeScale = 0.0f;
    };

    class ClientStartTimer
    {
        time_t TimeRemaining = time_t(0);
        time_t TotalTime = time_t(0);
        int32 Type = 0;
    };

    class ClientDisenchantCredit
    {
        ObjectGuid Disenchanter;
        ItemInstance Item;
    };

    class ClientSuspendToken
    {
        ClientSuspendReason Reason;
        uint32 Sequence = 0;
    };

    class ClientResumeToken
    {
        uint32 Sequence = 0;
        ClientSuspendReason Reason;
    };

    class ClientCancelSpellVisual
    {
        ObjectGuid Source;
        int32 SpellVisualID = 0;
    };

    class ClientPlaySpellVisual
    {
        ObjectGuid Source;
        ObjectGuid Target;
        uint16 MissReason = 0;
        int32 SpellVisualID = 0;
        bool SpeedAsTime = false;
        uint16 ReflectStatus = 0;
        float TravelSpeed = 0.0f;
        Vector3 TargetPosition;
    };

    class ClientCancelOrphanSpellVisual
    {
        int32 SpellVisualID = 0;
    };

    class ClientPlayOrphanSpellVisual
    {
        ObjectGuid Target;
        Vector3 SourceLocation;
        int32 SpellVisualID = 0;
        bool SpeedAsTime = false;
        float TravelSpeed = 0.0f;
        Vector3 SourceOrientation;
        Vector3 TargetLocation;
    };

    class ClientCancelSpellVisualKit
    {
        ObjectGuid Source;
        int32 SpellVisualKitID = 0;
    };

    class ClientPlaySpellVisualKit
    {
        ObjectGuid Unit;
        int32 KitType = 0;
        uint32 Duration = 0;
        int32 KitRecID = 0;
    };

    class ClientGameObjectPlaySpellVisualKit
    {
        ObjectGuid Object;
        int32 KitRecID = 0;
        int32 KitType = 0;
        uint32 Duration = 0;
    };

    class ClientAddItemPassive
    {
        int32 SpellID = 0;
    };

    class ClientRemoveItemPassive
    {
        int32 SpellID = 0;
    };

    class ClientSendItemPassives
    {
        std::vector<int32> SpellID;
    };

    class ClientWorldServerInfo
    {
        Optional<uint32> IneligibleForLootMask;
        time_t WeeklyReset = time_t(0);
        Optional<uint32> InstanceGroupSize;
        uint8 IsTournamentRealm = 0;
        Optional<uint32> RestrictedAccountMaxLevel;
        Optional<uint32> RestrictedAccountMaxMoney;
        uint32 DifficultyID = 0;
    };

    class ClientAccountMountUpdate
    {
        std::vector<int32> MountSpellIDs;
        std::vector<bool> MountIsFavorite;
        bool IsFullUpdate = false;
    };

    class ClientLastWeeklyReset
    {
        time_t Reset = time_t(0);
    };

    class ClientRuneRegenDebug
    {
        uint32 Time = 0;
        uint32 int32erval = 0;
        int32 RuneStart[6] = { };
        int32 RuneEnd[6] = { };
        float RegenRate[4] = 0.0f;
    };

    class ClientGMAccountOnlineResponse
    {
        ObjectGuid PlayerGuid;
        uint32 AccountID = 0;
    };

    class ClientVendorInventory
    {
        uint8 Reason = 0;
        std::vector<CliVendorItem> Items;
        ObjectGuid Vendor;
    };

    class ClientRestrictedAccountWarning
    {
        uint32 Arg = 0;
        uint8 Type = 0;
    };

    class ClientSetPlayHoverAnim
    {
        ObjectGuid UnitGUID;
        bool PlayHoverAnim = false;
    };

    class ClientLoadCUFProfiles
    {
        std::vector<CliCUFProfile> Profiles;
    };

    class ClientSuppressNPCGreetings
    {
        bool SuppressNPCGreetings = false;
        ObjectGuid UnitGUID;
    };

    class ClientDestroyObject
    {
        bool IsDead = false;
        ObjectGuid Guid;
    };

    class ClientPartyInvite
    {
        bool AllowMultipleRoles = false;
        uint32 InviterCfgRealmID = 0;
        bool MightCRZYou = false;
        bool CanAccept = false;
        ObjectGuid InviterGuid;
        bool MustBeBNetFriend = false;
        uint32 LfgCompletedMask = 0;
        uint32 ProposedRoles = 0;
        std::vector<uint32> LfgSlots;
        bool IsXRealm = false;
        std::string InviterRealmName;
        std::string InviterName;
        ObjectGuid InviterBNetAccountID;
    };

    class ClientDumpRideTicket
    {
        std::string Description;
    };

    class ClientDumpRideTicketsResponse
    {
        std::vector<ClientDumpRideTicket> Ticket;
    };

    class CliSavedThrottleObjectState
    {
        uint32 MaxTries = 0;
        uint32 PerMilliseconds = 0;
        uint32 TryCount = 0;
        uint32 LastResetTimeBeforeNow = 0;
    };

    class CliEuropaTicketConfig
    {
        CliSavedThrottleObjectState ThrottleState;
    };

    class ClientSessionAlertConfig
    {
        int32 Delay = 0;
        int32 Period = 0;
        int32 DisplayTime = 0;
    };

    class ClientFeatureSystemStatus
    {
        bool VoiceEnabled = false;
        bool BrowserEnabled = false;
        bool BpayStoreAvailable = false;
        bool RecruitAFriendSendingEnabled = false;
        bool BpayStoreEnabled = false;
        Optional<ClientSessionAlertConfig> SessionAlert;
        uint32 ScrollOfResurrectionMaxRequestsPerDay = 0;
        bool ScrollOfResurrectionEnabled = false;
        Optional<CliEuropaTicketConfig> EuropaTicketSystemStatus;
        uint32 ScrollOfResurrectionRequestsRemaining = 0;
        uint32 CfgRealmID = 0;
        uint8 ComplaintStatus = 0;
        int32 CfgRealmRecID = 0;
        bool ItemRestorationButtonEnabled = false;
        bool CharUndeleteEnabled = false;
        bool BpayStoreDisabledByParentalControls = false;
    };

    class ClientFeatureSystemStatusGlueScreen
    {
        bool BpayStoreAvailable = false;
        bool BpayStoreDisabledByParentalControls = false;
        bool CharUndeleteEnabled = false;
        bool BpayStoreEnabled = false;
    };

    class ClientPVPSeason
    {
        int32 PreviousSeason = 0;
        int32 CurrentSeason = 0;
    };

    class ClientRequestPVPRewardsResponse
    {
        int32 RatedRewardPointsThisWeek = 0;
        int32 ArenaRewardPointsThisWeek = 0;
        int32 RatedMaxRewardPointsThisWeek = 0;
        int32 ArenaRewardPoints = 0;
        int32 RandomRewardPointsThisWeek = 0;
        int32 ArenaMaxRewardPointsThisWeek = 0;
        int32 RatedRewardPoints = 0;
        int32 MaxRewardPointsThisWeek = 0;
        int32 RewardPointsThisWeek = 0;
        int32 RandomMaxRewardPointsThisWeek = 0;
    };

    class ClientGameObjectActivateAnimKit
    {
        bool Maintain = false;
        ObjectGuid ObjectGUID;
        int32 AnimKitID = 0;
    };

    class ClientGameObjectCustomAnim
    {
        ObjectGuid ObjectGUID;
        uint32 CustomAnim = 0;
        bool PlayAsDespawn = false;
    };

    class ClientGameObjectDespawn
    {
        ObjectGuid ObjectGUID;
    };

    class ClientGameObjectPlaySpellVisual
    {
        ObjectGuid ObjectGUID;
        ObjectGuid ActivatorGUID;
        int32 SpellVisualID = 0;
    };

    class ClientMapObjEvents
    {
        uint32 UniqueID = 0;
        Data Events;
    };

    class ClientMissileCancel
    {
        ObjectGuid OwnerGUID;
        bool Reverse = false;
        int32 SpellID = 0;
    };

    class ClientVoidStorageFailed
    {
        uint8 Reason = 0;
    };

    class VoidItem
    {
        ObjectGuid Guid;
        ObjectGuid Creator;
        uint32 Slot = 0;
        ItemInstance Item;
    };

    class ClientVoidStorageContents
    {
        std::vector<VoidItem> Items;
    };

    class ClientVoidStorageTransferChanges
    {
        std::vector<ObjectGuid> RemovedItems;
        std::vector<VoidItem> AddedItems;
    };

    class ClientVoidTransferResult
    {
        int32 Result = 0;
    };

    class ClientVoidItemSwapResponse
    {
        ObjectGuid VoidItemB;
        ObjectGuid VoidItemA;
        uint32 VoidItemSlotB = 0;
        uint32 VoidItemSlotA = 0;
    };

    class ClientXPGainAborted
    {
        ObjectGuid Victim;
        int32 XpToAdd = 0;
        int32 XpGainReason = 0;
        int32 XpAbortReason = 0;
    };

    class ClientPrintNotification
    {
        std::string NotifyText;
    };

    class ClientFailedPlayerCondition
    {
        int32 ConditionID = 0;
    };

    class ClientCustomLoadScreen
    {
        int32 TeleportSpellID = 0;
    };

    class ShipTransferPending
    {
        uint32 ID = 0;
        int32 OriginMapID = 0;
    };

    class ClientTransferPending
    {
        int32 MapID = 0;
        Optional<ShipTransferPending> Ship;
        Optional<int32> TransferSpellID;
    };

    class ClientGameEventDebugLog
    {
        ObjectGuid TriggeredBy;
        int32 EventID = 0;
        int32 EventType = 0;
        std::string Reason;
        std::string TriggeredByName;
        std::string EventName;
    };

    class ClientServerPerfStat
    {
        std::string Text;
    };

    class ClientServerPerf
    {
        std::vector<ClientServerPerfStat> Stats;
    };

    class ClientAreaTriggerMovementUpdate
    {
        Vector3 Start;
        Vector3 End;
    };

    class ClientAdjustSplineDuration
    {
        ObjectGuid Unit;
        float Scale = 0.0f;
    };

    class ClientLearnTalentFailed
    {
        int32 Reason = 0;
    };

    class ClientUpdateTalentData
    {
        TalentInfoUpdate Info;
    };

    class ClientGMRequestPlayerInfo
    {
        bool Success = false;
        std::string Name;
    };

    class ClientGMSummon
    {
        bool Success = false;
    };

    class ClientGhost
    {
        ObjectGuid Target;
    };

    class ClientLFGBlackListSlot
    {
        int32 Slot = 0;
        int32 Reason = 0;
        int32 SubReason1 = 0;
        int32 SubReason2 = 0;
    };

    class ClientLFGBlackList
    {
        ObjectGuid Guid;
        std::vector<ClientLFGBlackListSlot> Slots;
    };

    class ClientLFGJoinResult
    {
        uint8 Result = 0;
        std::vector<ClientLFGBlackList> BlackList;
        uint8 ResultDetail = 0;
        CliRideTicket Ticket;
    };

    class ClientLFGListJoinResult
    {
        CliRideTicket Ticket;
        uint8 ResultDetail = 0;
        uint8 Result = 0;
    };

    class ClientLFGQueueStatus
    {
        CliRideTicket Ticket;
        uint32 QueuedTime = 0;
        uint32 AvgWaitTime = 0;
        uint32 Slot = 0;
        uint32 AvgWaitTimeMe = 0;
        uint8 LastNeeded[3] = { };
        uint32 AvgWaitTimeByRole[3] = { };
    };

    class ClientLFGRoleCheckUpdateMember
    {
        ObjectGuid Guid;
        bool RoleCheckComplete = false;
        uint32 RolesDesired = 0;
        uint8 Level = 0;
    };

    class ClientLFGRoleCheckUpdate
    {
        bool IsBeginning = false;
        std::vector<uint32> JoinSlots;
        uint64 BgQueueID = 0;
        uint8 PartyIndex = 0;
        uint8 RoleCheckStatus = 0;
        std::vector<ClientLFGRoleCheckUpdateMember> Members;
    };

    class ClientLFGUpdateStatus
    {
        uint32 RequestedRoles = 0;
        bool NotifyUI = false;
        std::vector<uint32> Slots;
        bool LfgJoined = false;
        uint8 Reason = 0;
        std::vector<ObjectGuid> SuspendedPlayers;
        uint8 SubType = 0;
        bool Queued = false;
        std::string Comment;
        CliRideTicket Ticket;
        bool Joined = false;
        bool IsParty = false;
        uint8 Needs[3] = { };
    };

    class ClientLFGListUpdateStatus
    {
        bool Listed = false;
        LFGListJoinRequest Request;
        uint8 Reason = 0;
        CliRideTicket Ticket;
    };

    class ClientLFGListUpdateBlacklist
    {
        LFGListBlacklist Blacklist;
    };

    class ClientLFGProposalUpdatePlayer
    {
        uint32 Roles = 0;
        bool Me = false;
        bool SameParty = false;
        bool MyParty = false;
        bool Responded = false;
        bool Accepted = false;
    };

    class ClientLFGProposalUpdate
    {
        bool ProposalSilent = false;
        std::vector<ClientLFGProposalUpdatePlayer> Players;
        uint32 CompletedMask = 0;
        uint64 InstanceID = 0;
        bool ValidCompletedMask = false;
        uint32 Slot = 0;
        CliRideTicket Ticket;
        int8 State = 0;
        uint32 ProposalID = 0;
    };

    class ClientLFGSearchResultParty
    {
        ObjectGuid Guid;
        uint32 ChangeMask = 0;
        std::string Comment;
        uint64 InstanceID = 0;
        uint32 InstanceCompletedMask = 0;
        uint8 Needs[3] = { };
    };

    class ClientLFGSearchResultPlayer
    {
        ObjectGuid Guid;
        uint32 ChangeMask = 0;
        uint8 Level = 0;
        uint8 ChrClass = 0;
        uint8 Race = 0;
        uint32 Armor = 0;
        uint32 SpellDamage = 0;
        uint32 PlusHealing = 0;
        uint32 CritMelee = 0;
        uint32 CritRanged = 0;
        uint32 CritSpell = 0;
        float Mp5 = 0.0f;
        float Mp5InCombat = 0.0f;
        uint32 AttackPower = 0;
        uint32 Agility = 0;
        uint32 MaxHealth = 0;
        uint32 MaxMana = 0;
        uint32 BossKills = 0;
        float GearRating = 0.0f;
        float AvgItemLevel = 0.0f;
        uint32 DefenseRating = 0;
        uint32 DodgeRating = 0;
        uint32 BlockRating = 0;
        uint32 ParryRating = 0;
        uint32 HasteRating = 0;
        float Expertise = 0.0f;
        uint32 SpecID = 0;
        uint32 VirtualRealmAddress = 0;
        uint32 NativeRealmAddress = 0;
        std::string Comment;
        bool IsLeader = false;
        ObjectGuid PartyGuid;
        uint8 RolesDesired = 0;
        uint32 Area = 0;
        uint8 Status = 0;
        uint64 InstanceID = 0;
        uint32 InstanceCompletedMask = 0;
    };

    class ClientLFGSearchResults
    {
        bool Incremental = false;
        std::vector<ObjectGuid> Removes;
        CliRideTicket Ticket;
        uint32 SlotID = 0;
        uint32 CountTotalParties = 0;
        uint32 CountTotalPlayers = 0;
        uint32 SlotType = 0;
        std::vector<ClientLFGSearchResultParty> Parties;
        std::vector<ClientLFGSearchResultPlayer> Players;
    };

    class CliServerInfoLine
    {
        std::string Label;
        std::string Data;
    };

    class ClientServerInfoResponse
    {
        std::vector<CliServerInfoLine> UserServerInfo;
        std::vector<CliServerInfoLine> WorldServerInfo;
    };

    class LootItem
    {
        LootListItemType Type;
        LootItemUiType UiType;
        uint32 Quantity = 0;
        uint8 LootItemType = 0;
        uint8 LootListID = 0;
        bool CanTradeToTapList = false;
        ItemInstance Loot;
    };

    class LootCurrency
    {
        uint32 CurrencyID = 0;
        uint32 Quantity = 0;
        uint8 LootListID = 0;
        LootItemUiType UiType;
    };

    class ClientLootContents
    {
        ObjectGuid LootObj;
        ObjectGuid Owner;
        std::vector<LootItem> Items;
    };

    class ClientNeutralPlayerFactionSelectResult
    {
        bool Success = false;
        int32 NewRaceID = 0;
    };

    class CliBnetLicense
    {
        int32 LicenseID = 0;
        time_t Expiration = time_t(0);
    };

    class ClientAccountInfoResponse
    {
        int32 BnetAccountID = 0;
        std::vector<CliBnetLicense> GameAccountLicenses;
        std::vector<CliBnetLicense> BnetAccountLicenses;
        int32 GameAccountFlags = 0;
        int32 LocalAccountFlags = 0;
        std::string BnetAccountName;
        int32 BnetAccountFlags = 0;
        int32 GameAccountID = 0;
        std::string GameAccountName;
    };

    class ClientSetDFFastLaunchResult
    {
        bool Set = false;
    };

    class ClientSetLFGTimeWalker
    {
        int32 LfgDungeonID = 0;
    };

    class ClientSupercededSpells
    {
        std::vector<int32> SpellID;
        std::vector<int32> Superceded;
    };

    class ClientLearnedSpells
    {
        std::vector<int32> SpellID;
        bool SuppressMessaging = false;
    };

    class ClientUnlearnedSpells
    {
        std::vector<int32> SpellID;
    };

    class ClientPetLearnedSpells
    {
        std::vector<int32> SpellID;
    };

    class ClientPetUnlearnedSpells
    {
        std::vector<int32> SpellID;
    };

    class ClientUpdateActionButtons
    {
        uint64 ActionButtons[132] = 0;
        uint8 Reason = 0;
    };

    class ClientLFGSlotInvalid
    {
        int32 SubReason1 = 0;
        int32 SubReason2 = 0;
        uint32 Reason = 0;
    };

    class ClientSceneObjectEvent
    {
        CliSceneObjectEvent SceneEvent;
        ObjectGuid SceneObjectGUID;
    };

    class ClientSceneObjectPetBattleInitialUpdate
    {
        PetBattleFullUpdate MsgData;
        ObjectGuid SceneObjectGUID;
    };

    class ClientSceneObjectPetBattleFirstRound
    {
        PetBattleRoundResult MsgData;
        ObjectGuid SceneObjectGUID;
    };

    class ClientSceneObjectPetBattleRoundResult
    {
        PetBattleRoundResult MsgData;
        ObjectGuid SceneObjectGUID;
    };

    class ClientSceneObjectPetBattleReplacementsMade
    {
        PetBattleRoundResult MsgData;
        ObjectGuid SceneObjectGUID;
    };

    class ClientSceneObjectPetBattleFinalRound
    {
        ObjectGuid SceneObjectGUID;
        PetBattleFinalRound MsgData;
    };

    class ClientSceneObjectPetBattleFinished
    {
        ObjectGuid SceneObjectGUID;
    };

    class ClientSendAllItemDurability
    {
        std::vector<int32> MaxDurability;
    };

    class ClientBattlePetOwnerInfo
    {
        ObjectGuid Guid;
        uint32 PlayerVirtualRealm = 0;
        uint32 PlayerNativeRealm = 0;
    };

    class ClientBattlePet
    {
        ObjectGuid BattlePetGUID;
        int32 SpeciesID = 0;
        int32 CreatureID = 0;
        int32 DisplayID = 0;
        uint16 BreedID = 0;
        uint16 Level = 0;
        uint16 Xp = 0;
        uint16 BattlePetDBFlags = 0;
        int32 Power = 0;
        int32 Health = 0;
        int32 MaxHealth = 0;
        int32 Speed = 0;
        std::string CustomName;
        Optional<ClientBattlePetOwnerInfo> OwnerInfo;
        bool NoRename = false;
        uint8 BreedQuality = 0;
    };

    class ClientBattlePetUpdates
    {
        bool AddedPet = false;
        std::vector<ClientBattlePet> Pets;
    };

    class ClientBattlePetTrapLevel
    {
        int16 TrapLevel = 0;
    };

    class ClientPetBattleSlot
    {
        ObjectGuid BattlePetGUID;
        int32 CollarID = 0;
        uint8 SlotIndex = 0;
        bool Locked = false;
    };

    class ClientPetBattleSlotUpdates
    {
        bool NewSlotUnlocked = false;
        bool AutoSlotted = false;
        std::vector<ClientPetBattleSlot> Slots;
    };

    class ClientBattlePetJournal
    {
        bool HasJournalLock = false;
        std::vector<ClientBattlePet> Pets;
        int16 TrapLevel = 0;
        std::vector<ClientPetBattleSlot> Slots;
    };

    class ClientBattlePetDeleted
    {
        ObjectGuid BattlePetGUID;
    };

    class ClientBattlePetRevoked
    {
        ObjectGuid BattlePetGUID;
    };

    class ClientBattlePetRestored
    {
        ObjectGuid BattlePetGUID;
    };

    class CliPartyLFGInfo
    {
        uint8 MyLfgFlags = 0;
        uint32 LfgSlot = 0;
        uint32 MyLfgRandomSlot = 0;
        bool LfgAborted = false;
        uint8 MyLfgPartialClear = 0;
        float MyLfgGearDiff = 0.0f;
        uint8 MyLfgStrangerCount = 0;
        uint8 MyLfgKickVoteCount = 0;
        uint8 LfgBootCount = 0;
        bool MyLfgFirstReward = false;
    };

    class CliPartyPlayerInfo
    {
        std::string Name;
        ObjectGuid Guid;
        uint8 Connected = 0;
        uint8 Subgroup = 0;
        uint8 Flags = 0;
        uint8 RolesAssigned = 0;
    };

    class CliPartyLootSettings
    {
        ObjectGuid LootMaster;
        uint8 LootMethod = 0;
        uint8 LootThreshold = 0;
    };

    class CliPartyDifficultySettings
    {
        uint32 DungeonDifficultyID = 0;
        uint32 RaidDifficultyID = 0;
    };

    class ClientPartyUpdate
    {
        uint8 PartyFlags = 0;
        Optional<CliPartyLootSettings> LootSettings;
        Optional<CliPartyLFGInfo> LfgInfo;
        ObjectGuid LeaderGUID;
        uint8 PartyType = 0;
        ObjectGuid PartyGUID;
        uint8 PartyIndex = 0;
        std::vector<CliPartyPlayerInfo> PlayerList;
        uint32 SequenceNum = 0;
        Optional<CliPartyDifficultySettings> DifficultySettings;
        int32 MyIndex = 0;
    };

    class ClientReadyCheckStarted
    {
        uint8 PartyIndex = 0;
        ObjectGuid InitiatorGUID;
        ObjectGuid PartyGUID;
        time_t Duration = time_t(0);
    };

    class ClientReadyCheckResponse
    {
        bool IsReady = false;
        ObjectGuid Player;
        ObjectGuid PartyGUID;
    };

    class ClientReadyCheckCompleted
    {
        ObjectGuid PartyGUID;
        uint8 PartyIndex = 0;
    };

    class ClientPetBattleRequestFailed
    {
        uint8 Reason = 0;
    };

    class ClientPetBattlePVPChallenge
    {
        ObjectGuid ChallengerGUID;
        PetBattleLocations Location;
    };

    class ClientPetBattleFinalizeLocation
    {
        PetBattleLocations Location;
    };

    class ClientPetBattleInitialUpdate
    {
        PetBattleFullUpdate MsgData;
    };

    class ClientPetBattleFirstRound
    {
        PetBattleRoundResult MsgData;
    };

    class ClientPetBattleRoundResult
    {
        PetBattleRoundResult MsgData;
    };

    class ClientPetBattleReplacementsMade
    {
        PetBattleRoundResult MsgData;
    };

    class ClientPetBattleFinalRound
    {
        PetBattleFinalRound MsgData;
    };

    class ClientPetBattleMaxGameLengthWarning
    {
        PetBattleMaxGameLengthWarning MsgData;
    };

    class ClientStartElapsedTimer
    {
        ElaspedTimer Timer;
    };

    class ClientStopElapsedTimer
    {
        uint32 TimerID = 0;
        bool KeepTimer = false;
    };

    class ClientStartElapsedTimers
    {
        std::vector<ElaspedTimer> Timers;
    };

    class ItemReward
    {
        int32 ItemID = 0;
        int32 ItemDisplayID = 0;
        uint32 Quantity = 0;
    };

    class CurrencyReward
    {
        uint32 CurrencyID = 0;
        uint32 Quantity = 0;
    };

    class ChallengeModeReward
    {
        std::vector<ItemReward> ItemRewards;
        std::vector<CurrencyReward> CurrencyRewards;
        uint32 Money = 0;
    };

    class ClientChallengeModeComplete
    {
        uint32 MapID = 0;
        uint32 Time = 0;
        uint32 MedalEarned = 0;
        ChallengeModeReward Reward;
    };

    class MapChallengeModeReward
    {
        int32 MapID = 0;
        std::vector<ChallengeModeReward> RewardsPerMedal;
    };

    class ClientChallegeModeRewards
    {
        std::vector<MapChallengeModeReward> Rewards;
        std::vector<ItemReward> TierRewards;
    };

    class ClientChallengeModeMap
    {
        int32 MapID = 0;
        int32 BestCompletionMilliseconds = 0;
        int32 LastCompletionMilliseconds = 0;
        int32 BestMedal = 0;
        Data BestMedalDate;
        std::vector<int16> BestSpecID;
    };

    class ClientChallengeModeAllMapStats
    {
        std::vector<ClientChallengeModeMap> Maps;
    };

    class ClientChallengeModeMapStatsUpdate
    {
        ClientChallengeModeMap MapData;
    };

    class ClientChallengeModeMember
    {
        ObjectGuid Guid;
        uint32 VirtualRealmAddress = 0;
        uint32 NativeRealmAddress = 0;
        int32 SpecializationID = 0;
    };

    class ClientChallengeModeAttempt
    {
        uint32 InstanceRealmAddress = 0;
        uint32 AttemptID = 0;
        int32 CompletionTime = 0;
        Data CompletionDate;
        int32 MedalEarned = 0;
        std::vector<ClientChallengeModeMember> Members;
    };

    class ClientChallengeModeRequestLeadersResult
    {
        time_t LastRealmUpdate = time_t(0);
        std::vector<ClientChallengeModeAttempt> GuildLeaders;
        int32 MapID = 0;
        time_t LastGuildUpdate = time_t(0);
        std::vector<ClientChallengeModeAttempt> RealmLeaders;
    };

    class ClientChallengeModeNewPlayerRecord
    {
        int32 Medal = 0;
        int32 CompletionMilliseconds = 0;
        int32 MapID = 0;
    };

    class ClientRespecWipeConfirm
    {
        ObjectGuid RespecMaster;
        uint32 Cost = 0;
        int8 RespecType = 0;
    };

    class ClientGMCharacterRestoreResponseWarning
    {
        std::string Text;
    };

    class ClientGMCharacterRestoreResponse
    {
        uint32 SrcAccount = 0;
        std::vector<ClientGMCharacterRestoreResponseWarning> Warningstd::strings;
        std::string ResultDescription;
        uint32 DstAccount = 0;
        bool Success = false;
        uint32 ResultCode = 0;
        uint32 Token = 0;
        ObjectGuid NewCharacterGUID;
        ObjectGuid OldCharacterGUID;
    };

    class ClientLootResponse
    {
        uint32 Coins = 0;
        uint8 LootMethod = 0;
        uint8 Threshold = 0;
        ObjectGuid LootObj;
        std::vector<LootCurrency> Currencies;
        bool PersonalLooting = false;
        uint8 AcquireReason = 0;
        bool Acquired = false;
        bool AELooting = false;
        ObjectGuid Owner;
        uint8 FailureReason = 0;
        std::vector<LootItem> Items;
    };

    class ClientLootRemoved
    {
        ObjectGuid LootObj;
        ObjectGuid Owner;
        uint8 LootListID = 0;
    };

    class ClientLootUpdated
    {
        LootItem Item;
        ObjectGuid LootObj;
    };

    class ClientCoinRemoved
    {
        ObjectGuid LootObj;
    };

    class ClientAELootTargets
    {
        uint32 Count = 0;
    };

    class ClientLootRelease
    {
        ObjectGuid LootObj;
        ObjectGuid Owner;
    };

    class ClientLootMoneyNotify
    {
        uint32 Money = 0;
        bool SoleLooter = false;
    };

    class ClientStartLootRoll
    {
        uint32 RollTime = 0;
        uint8 Method = 0;
        LootItem Item;
        int32 MapID = 0;
        ObjectGuid LootObj;
        uint8 ValidRolls = 0;
    };

    class ClientLootRoll
    {
        ObjectGuid Player;
        int32 Roll = 0;
        LootItem Item;
        uint8 RollType = 0;
        ObjectGuid LootObj;
        bool Autopassed = false;
    };

    class ClientMasterLootCandidateList
    {
        std::vector<ObjectGuid> Players;
        ObjectGuid LootObj;
    };

    class ClientLootItemList
    {
        std::vector<LootItem> Items;
        ObjectGuid LootObj;
    };

    class ClientLootRollsComplete
    {
        ObjectGuid LootObj;
        uint8 LootListID = 0;
    };

    class ClientLootAllPassed
    {
        ObjectGuid LootObj;
        LootItem Item;
    };

    class ClientLootRollWon
    {
        ObjectGuid Winner;
        ObjectGuid LootObj;
        uint8 RollType = 0;
        int32 Roll = 0;
        LootItem Item;
    };

    class ClientSetItemChallengeModeData
    {
        ObjectGuid ItemGUID;
        int32 Stats[6] = { };
    };

    class ClientClearItemChallengeModeData
    {
        ObjectGuid ItemGUID;
    };

    class ClientItemPushResult
    {
        uint32 BattlePetBreedQuality = 0;
        ObjectGuid ItemGUID;
        int32 SlotInBag = 0;
        int32 QuantityInInventory = 0;
        int32 Quantity = 0;
        bool Pushed = false;
        bool DisplayText = false;
        int32 BattlePetLevel = 0;
        uint8 Slot = 0;
        bool Created = false;
        int32 BattlePetBreedID = 0;
        bool IsBonusRoll = false;
        ObjectGuid PlayerGUID;
        ItemInstance Item;
        int32 BattlePetSpeciesID = 0;
    };

    class ClientDisplayToast
    {
        bool BonusRoll = false;
        ToastType Type;
        uint32 CurrencyID = 0;
        uint8 DisplayToastMethod = 0;
        bool Mailed = false;
        ItemInstance Item;
        int32 LootSpec = 0;
        uint32 Quantity = 0;
    };

    class ClientAreaTriggerDebugSweep
    {
        ObjectGuid TriggerGUID;
        uint32 TimeFromCreation1 = 0;
        uint32 TimeFromCreation0 = 0;
    };

    class ClientAreaTriggerDebugPlayerInside
    {
        ObjectGuid TriggerGUID;
        bool Inside = false;
    };

    class ClientResetAreaTrigger
    {
        ObjectGuid TriggerGUID;
        CliAreaTrigger AreaTrigger;
    };

    class ClientAreaTriggerRePath
    {
        CliAreaTriggerSpline AreaTriggerSpline;
        ObjectGuid TriggerGUID;
    };

    class ClientAreaTriggerReShape
    {
        CliAreaTriggerPolygon AreaTriggerPolygon;
        ObjectGuid TriggerGUID;
    };

    class ClientSetPetSpecialization
    {
        uint16 SpecID = 0;
    };

    class ClientBlackMarketOpenResult
    {
        ObjectGuid NpcGUID;
        bool Open = false;
    };

    class ClientBlackMarketItem
    {
        int32 MarketID = 0;
        int32 SellerNPC = 0;
        ItemInstance Item;
        int32 Quantity = 0;
        uint64 MinBid = 0;
        uint64 MinIncrement = 0;
        uint64 CurrentBid = 0;
        int32 SecondsRemaining = 0;
        bool HighBid = false;
        int32 NumBids = 0;
    };

    class ClientBlackMarketRequestItemsResult
    {
        time_t LastUpdateID = time_t(0);
        std::vector<ClientBlackMarketItem> Items;
    };

    class ClientBlackMarketBidOnItemResult
    {
        int32 MarketID = 0;
        ItemInstance Item;
        int32 Result = 0;
    };

    class ClientBlackMarketOutbid
    {
        ItemInstance Item;
        int32 MarketID = 0;
        int32 RandomPropertiesID = 0;
    };

    class ClientBlackMarketWon
    {
        int32 MarketID = 0;
        int32 RandomPropertiesID = 0;
        ItemInstance Item;
    };

    class ClientScenarioState
    {
        std::vector<BonusObjectiveData> BonusObjectives;
        bool ScenarioComplete = false;
        std::vector<CriteriaProgress> CriteriaProgress;
        int32 CurrentStep = 0;
        uint32 WaveCurrent = 0;
        uint32 DifficultyID = 0;
        uint32 TimerDuration = 0;
        int32 ScenarioID = 0;
        uint32 WaveMax = 0;
    };

    class ClientScenarioProgressUpdate
    {
        CriteriaProgress Progress;
    };

    class ClientGroupNewLeader
    {
        uint8 PartyIndex = 0;
        std::string Name;
    };

    class RaidTargetSymbol
    {
        ObjectGuid Target;
        uint8 Symbol = 0;
    };

    class ClientSendRaidTargetUpdateAll
    {
        std::vector<RaidTargetSymbol> Targets;
        uint8 PartyIndex = 0;
    };

    class ClientSendRaidTargetUpdateSingle
    {
        ObjectGuid ChangedBy;
        ObjectGuid Target;
        uint8 PartyIndex = 0;
        uint8 Symbol = 0;
    };

    class ClientRandomRoll
    {
        ObjectGuid Roller;
        int32 Result = 0;
        int32 Max = 0;
        int32 Min = 0;
    };

    class CliInspectEnchantData
    {
        uint32 Id = 0;
        uint8 Index = 0;
    };

    class CliInspectItemData
    {
        ObjectGuid CreatorGUID;
        ItemInstance Item;
        uint8 Index = 0;
        bool Usable = false;
        std::vector<CliInspectEnchantData> Enchants;
    };

    class CliInspectGuildData
    {
        ObjectGuid GuildGUID;
        long GuildXP;
        int32 GuildLevel = 0;
        int32 NumGuildMembers = 0;
    };

    class ClientInspectResult
    {
        std::vector<CliInspectItemData> Items;
        int32 ClassID = 0;
        std::vector<uint16> Talents;
        std::vector<uint16> Glyphs;
        Optional<CliInspectGuildData> GuildData;
        ObjectGuid InspecteeGUID;
        int32 SpecializationID = 0;
    };

    class ScenarioPOIPointData
    {
        int32 X = 0;
        int32 Y = 0;
    };

    class ScenarioBlobData
    {
        int32 BlobID = 0;
        int32 MapID = 0;
        int32 WorldMapAreaID = 0;
        int32 Floor = 0;
        int32 Priority = 0;
        int32 Flags = 0;
        int32 WorldEffectID = 0;
        int32 PlayerConditionID = 0;
        std::vector<ScenarioPOIPointData> Points;
    };

    class ScenarioPOIData
    {
        int32 CriteriaTreeID = 0;
        std::vector<ScenarioBlobData> BlobData;
    };

    class ClientScenarioPOIs
    {
        std::vector<ScenarioPOIData> PoiInfo;
    };

    class ClientInstanceLock
    {
        uint32 MapID = 0;
        uint32 DifficultyID = 0;
        uint64 InstanceID = 0;
        bool Locked = false;
        bool Extended = false;
        uint32 TimeRemaining = 0;
        uint32 Completed_mask = 0;
    };

    class ClientInstanceInfo
    {
        std::vector<ClientInstanceLock> Locks;
    };

    class ClientConsoleWrite
    {
        uint32 Color = 0;
        std::string Line;
    };

    class ClientAccountCriteriaUpdate
    {
        CriteriaProgress Progress;
    };

    class ClientPlayScene
    {
        CliPlaySceneData PlayData;
    };

    class ClientCancelScene
    {
        uint32 SceneInstanceID = 0;
    };

    class ClientBattlePetError
    {
        Battlepetresult BattlePetResult;
        int32 CreatureID = 0;
    };

    class ClientPetBattleQueueStatus
    {
        int32 Status = 0;
        std::vector<int32> SlotResult;
        CliRideTicket Ticket;
        Optional<long> AverageWaitTime;
        Optional<long> ClientWaitTime;
    };

    class ClientMailCommandResult
    {
        int32 Command = 0;
        int32 MailID = 0;
        int32 QtyInInventory = 0;
        int32 BagResult = 0;
        int32 AttachID = 0;
        int32 ErrorCode = 0;
    };

    class ClientNotifyReceivedMail
    {
        float Delay = 0.0f;
    };

    class ClientAddBattlenetFriendResponse
    {
        Optional<uint16> BattlenetError;
        uint64 ClientToken = 0;
        addbattlenetfrienderror Result;
    };

    class ClientItemUpgradeResult
    {
        bool Result = false;
    };

    class ClientMoveCharacterCheatSuccess
    {
        ObjectGuid CharacterGUID;
        Vector3 Position;
        int32 MapID = 0;
    };

    class ClientAchievementEarned
    {
        uint32 EarnerNativeRealm = 0;
        bool Initial = false;
        ObjectGuid Earner;
        Data Time;
        int32 AchievementID = 0;
        uint32 EarnerVirtualRealm = 0;
        ObjectGuid Sender;
    };

    class ClientAreaShareInfoResponse
    {
        uint32 AreaShareInfoID = 0;
        uint32 CurrentRealm = 0;
        uint32 AreaID = 0;
        std::vector<uint32> OtherRealms;
    };

    class ClientOpenLFGDungeonFinder
    {
        int32 DungeonID = 0;
    };

    class ClientLFGTeleportDenied
    {
        LfgTeleportResult Reason;
    };

    class AreaShareMappingInfo
    {
        uint32 AreaShareID = 0;
        std::vector<uint32> AreaIDs;
        uint32 HostingRealm = 0;
        std::vector<uint32> OtherRealms;
    };

    class ClientAreaShareMappingsResponse
    {
        std::vector<AreaShareMappingInfo> Mappings;
    };

    class ClientUpdateExpansionLevel
    {
        std::vector<RaceClassAvailability> AvailableClasses;
        Optional<uint8> ActiveExpansionLevel;
        std::vector<RaceClassAvailability> AvailableRaces;
    };

    class ClientControlUpdate
    {
        bool On = false;
        ObjectGuid Guid;
    };

    class ClientOpponentSpecData
    {
        ObjectGuid Guid;
        int32 SpecializationID = 0;
    };

    class ClientArenaPrepOpponentSpecializations
    {
        std::vector<ClientOpponentSpecData> OpponentData;
    };

    class ClientGMTicketInfo
    {
        int32 TicketID = 0;
        std::string TicketDescription;
        uint8 Category = 0;
        time_t TicketOpenTime = time_t(0);
        time_t OldestTicketTime = time_t(0);
        time_t UpdateTime = time_t(0);
        uint8 AssignedToGM = 0;
        uint8 OpenedByGM = 0;
        std::string WaitTimeOverrideMessage;
        int32 WaitTimeOverrideMinutes = 0;
    };

    class ClientGMTicketGetTicketResponse
    {
        Optional<ClientGMTicketInfo> Info;
        int32 Result = 0;
    };

    class RealmName
    {
        std::string Name;
    };

    class ClientGMNotifyAreaChange
    {
        std::vector<RealmName> OtherRealms;
        std::string AreaShareInternalName;
        RealmName CurrentRealm;
        uint8 AreaShareID = 0;
        uint32 AreaID = 0;
        uint32 CurrentRealmAddress = 0;
    };

    class ClientForceObjectRelink
    {
        ObjectGuid ObjectGUID;
    };

    class ClientDisplayPromotion
    {
        int32 PromotionID = 0;
    };

    class ClientSetPromotionResponse
    {
        bool Success = false;
        int32 PromotionID = 0;
    };

    class ServerFirstAchievement
    {
        ObjectGuid PlayerGuid;
        int32 AchievementID = 0;
    };

    class ClientServerFirstAchievements
    {
        std::vector<ServerFirstAchievement> Achievements;
    };

    class ClientCorpseLocation
    {
        ObjectGuid Transport;
        Vector3 Position;
        int32 ActualMapID = 0;
        bool Valid = false;
        int32 MapID = 0;
    };

    class ClientBreakTarget
    {
        ObjectGuid UnitGUID;
    };

    class ClientAttackStart
    {
        ObjectGuid Attacker;
        ObjectGuid Victim;
    };

    class ClientAttackStop
    {
        ObjectGuid Attacker;
        ObjectGuid Victim;
        bool NowDead = false;
    };

    class ClientCombatEventFailed
    {
        ObjectGuid Victim;
        ObjectGuid Attacker;
    };

    class ClientDuelRequested
    {
        ObjectGuid ArbiterGUID;
        ObjectGuid RequestedByGUID;
    };

    class ClientDuelCountdown
    {
        uint32 Countdown = 0;
    };

    class ClientDuelComplete
    {
        bool Started = false;
    };

    class ClientDuelWinner
    {
        std::string BeatenName;
        std::string WinnerName;
        bool Fled = false;
        uint32 BeatenVirtualRealmAddress = 0;
        uint32 WinnerVirtualRealmAddress = 0;
    };

    class ClientCanDuelResult
    {
        bool Result = false;
        ObjectGuid TargetGUID;
    };

    class ClientImmigrantHostSearchLog
    {
        bool Success = false;
        std::vector<ImmigrantHostSearchLog> Entries;
    };

    class ClientAccountProfile
    {
        std::string Filename;
        Data Profile;
    };

    class ClientChallengeModeDumpLeadersResult
    {
        int32 MapID = 0;
        bool Success = false;
        std::vector<ClientChallengeModeAttempt> Leaders;
    };

    class ClientChallengeModeDeleteLeaderResult
    {
        int32 MapID = 0;
        uint32 AttemptID = 0;
        bool Success = false;
    };

    class ClientDebugDrawLine
    {
        float Thickness = 0.0f;
        Vector3 A;
        Vector3 B;
        uint32 Colora = 0;
        uint32 Colorb = 0;
        uint32 Id = 0;
        uint32 Settings = 0;
        float Lifetime = 0.0f;
    };

    class ClientDebugDrawQuad
    {
        Vector2 Size;
        float Lifetime = 0.0f;
        uint32 Settings = 0;
        std::string Texture;
        uint32 Id = 0;
        Vector2 TopLeft;
        uint32 Flags = 0;
        Vector2 Uv_max;
        uint32 Color = 0;
        Vector2 Uv_min;
    };

    class ClientDebugDrawTriangle
    {
        uint32 Colorb = 0;
        uint32 Colora = 0;
        uint32 Settings = 0;
        Vector3 A;
        Vector3 C;
        uint32 Colorc = 0;
        Vector3 B;
        uint32 Id = 0;
        float Lifetime = 0.0f;
    };

    class ClientDebugDrawSphere
    {
        float Lifetime = 0.0f;
        uint32 Settings = 0;
        float Radius = 0.0f;
        Vector3 Center;
        uint32 Id = 0;
        uint32 Color = 0;
    };

    class ClientDebugDrawBox
    {
        uint32 Id = 0;
        uint32 Color = 0;
        float Lifetime = 0.0f;
        Vector3 Extents;
        V4 Matrix30;
        uint32 Settings = 0;
        V4 Matrix10;
        V4 Matrix20;
        V4 Matrix00;
    };

    class ClientDebugDrawCone
    {
        Vector3 Base;
        float Baseradius = 0.0f;
        uint32 Id = 0;
        Vector3 Direction;
        float Height = 0.0f;
        uint32 Color = 0;
        float Lifetime = 0.0f;
        uint32 Settings = 0;
    };

    class ClientDebugDrawCylinder
    {
        uint32 Id = 0;
        float Height = 0.0f;
        Vector3 Base;
        float Lifetime = 0.0f;
        uint32 Settings = 0;
        Vector3 Direction;
        float Radius = 0.0f;
        uint32 Color = 0;
    };

    class ClientDebugDrawDisk
    {
        float Lifetime = 0.0f;
        Vector3 Normal;
        float Outterradius = 0.0f;
        Vector3 Center;
        uint32 Settings = 0;
        uint32 Color = 0;
        float Innerradius = 0.0f;
        uint32 Id = 0;
    };

    class ClientDebugDrawSlice
    {
        Vector3 Direction;
        Vector3 Center;
        float EndAngle = 0.0f;
        uint32 Color = 0;
        float Outterradius = 0.0f;
        float Innerradius = 0.0f;
        float StartAngle = 0.0f;
        float Lifetime = 0.0f;
        uint32 Id = 0;
        Vector3 Normal;
        uint32 Settings = 0;
    };

    class ClientDebugDrawArrow
    {
        float Headscale = 0.0f;
        uint32 Settings = 0;
        float Lifetime = 0.0f;
        Vector3 Location;
        uint32 Color = 0;
        Vector3 Direction;
        uint32 Id = 0;
        float Length = 0.0f;
    };

    class ClientDebugDrawMatrix
    {
        float Lifetime = 0.0f;
        V4 Matrix00;
        uint32 Colory = 0;
        V4 Matrix30;
        uint32 Id = 0;
        uint32 Colorz = 0;
        V4 Matrix20;
        uint32 Settings = 0;
        V4 Matrix10;
        float Axisscale = 0.0f;
        uint32 Colorx = 0;
    };

    class ClientDebugDrawText
    {
        uint8 Alignment = 0;
        uint32 Id = 0;
        uint32 Color = 0;
        uint32 Settings = 0;
        float Lifetime = 0.0f;
        float Height = 0.0f;
        Vector2 Location;
        std::string Text;
    };

    class ClientDebugDrawText3D
    {
        uint32 Settings = 0;
        std::string Text;
        uint32 Id = 0;
        uint32 Color = 0;
        uint8 Alignment = 0;
        Vector3 Location;
        float Height = 0.0f;
        float Lifetime = 0.0f;
    };

    class ClientDebugDrawCancel
    {
        uint32 Id = 0;
    };

    class ClientDebugDrawAddGraph
    {
        std::string Label;
        Vector2 Bounds_min;
        uint32 Height = 0;
        uint32 Flags = 0;
        uint32 DefaultSampleColor = 0;
        uint32 SampleCapacity = 0;
        uint32 Id = 0;
        Vector2 Bounds_max;
        uint32 Width = 0;
    };

    class ClientDebugDrawAddGraphAt
    {
        std::string Label;
        uint32 DefaultSampleColor = 0;
        Vector2 Bounds_min;
        Vector2 Bounds_max;
        uint32 Width = 0;
        int32 X = 0;
        uint32 Height = 0;
        int32 Y = 0;
        uint32 SampleCapacity = 0;
        uint32 Flags = 0;
        uint32 Id = 0;
    };

    class ClientDebugDrawHideGraph
    {
        bool Hide = false;
        uint32 Id = 0;
    };

    class ClientDebugDrawResetGraph
    {
        uint32 Id = 0;
    };

    class ClientDebugDrawDestroyGraph
    {
        uint32 Id = 0;
    };

    class ClientDebugDrawSetGraphBounds
    {
        Vector2 Bounds_max;
        uint32 Id = 0;
        Vector2 Bounds_min;
    };

    class ClientDebugDrawSetGraphFrame
    {
        uint32 Height = 0;
        uint32 Width = 0;
        uint32 Id = 0;
    };

    class ClientDebugDrawSetGraphFrameAt
    {
        int32 Y = 0;
        uint32 Id = 0;
        int32 X = 0;
        uint32 Height = 0;
        uint32 Width = 0;
    };

    class ClientDebugDrawAddSample
    {
        uint32 Id = 0;
        float X = 0.0f;
        float Y = 0.0f;
        uint32 SourceID = 0;
    };

    class ClientDebugDrawSetSourceColor
    {
        uint32 Color = 0;
        uint32 Id = 0;
        uint32 SourceID = 0;
    };

    class LossOfControlInfo
    {
        uint8 AuraSlot = 0;
        uint8 EffectIndex = 0;
        int32 Type = 0;
        int32 Mechanic = 0;
    };

    class ClientLossOfControlAuraUpdate
    {
        std::vector<LossOfControlInfo> LossOfControlInfo;
    };

    class ClientAddLossOfControl
    {
        uint32 DurationRemaining = 0;
        ObjectGuid Caster;
        uint32 Duration = 0;
        uint32 LockoutSchoolMask = 0;
        int32 SpellID = 0;
        int32 Type = 0;
        int32 Mechanic = 0;
    };

    class ClientRemoveLossOfControl
    {
        int32 SpellID = 0;
        ObjectGuid Caster;
        int32 Type = 0;
    };

    class ClientDebugDrawAura
    {
        ObjectGuid Caster;
        int32 SpellID = 0;
        Vector3 Position;
    };

    class ClientQueryObjPosition
    {
        float Facing = 0.0f;
        Vector3 Position;
        uint32 MapID = 0;
        bool ToClipboard = false;
    };

    class ClientQueryObjRotation
    {
        float AnchorFacing = 0.0f;
        float Facing = 0.0f;
    };

    class PBQueueDumpMember
    {
        ObjectGuid MemberGUID;
        float AverageTeamRating = 0.0f;
        float CurrentTolerance = 0.0f;
        time_t SecondsInQueue = time_t(0);
    };

    class ClientPetBattleDebugQueueDumpResponse
    {
        std::vector<PBQueueDumpMember> Members;
        time_t AverageQueueTime = time_t(0);
    };

    class ClientAreaTriggerDenied
    {
        bool Entered = false;
        int32 AreaTriggerID = 0;
    };

    class ClientSetServerWowTime
    {
        uint32 EncodedTime = 0;
        int32 HolidayOffset = 0;
    };

    class ClientSetTimeZoneInformation
    {
        std::string ServerTimeTZ;
        std::string GameTimeTZ;
    };

    class ClientBattlePetCageDateError
    {
        int32 SecondsUntilCanCage = 0;
    };

    class PlayerChoiceResponseRewardEntry
    {
        int32 Id = 0;
        int32 DisplayID = 0;
        int32 Quantity = 0;
    };

    class PlayerChoiceResponseReward
    {
        int32 TitleID = 0;
        int32 PackageID = 0;