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;
        int32 SkillLineID = 0;
        uint32 SkillPointCount = 0;
        uint32 ArenaPointCount = 0;
        uint32 HonorPointCount = 0;
        uint64 Money = 0;
        uint32 Xp = 0;
        std::vector<PlayerChoiceResponseRewardEntry> Items;
        std::vector<PlayerChoiceResponseRewardEntry> Currencies;
        std::vector<PlayerChoiceResponseRewardEntry> Factions;
        std::vector<PlayerChoiceResponseRewardEntry> ItemChoices;
    };

    class PlayerChoiceResponse
    {
        int32 ResponseID = 0;
        std::string Answer;
        std::string Description;
        int32 ChoiceArtFileID = 0;
        Optional<PlayerChoiceResponseReward> Reward;
    };

    class ClientDisplayPlayerChoice
    {
        int32 ChoiceID = 0;
        std::string Question;
        std::vector<PlayerChoiceResponse> Responses;
    };

    class ShowZoneRLE
    {
        int32 Run = 0;
        uint8 CurID = 0;
    };

    class ClientShowZonesCheatResult
    {
        std::vector<ShowZoneRLE> Run;
    };

    class ClientTextEmote
    {
        ObjectGuid SourceGUID;
        ObjectGuid TargetGUID;
        int32 SoundIndex = 0;
        int32 EmoteID = 0;
    };

    class ClientPetGodMode
    {
        bool Enabled = false;
    };

    class ClientTaxiNodeStatus
    {
        Taxistatus Status;
        ObjectGuid Unit;
    };

    class ClientActivateTaxiReply
    {
        Taxireply Error;
    };

    class ClientShowBank
    {
        ObjectGuid Banker;
    };

    class ClientDBLookupResults
    {
        uint32 NumResults = 0;
        std::vector<uint8> Results;
    };

    class ClientGameSpeedSet
    {
        float NewSpeed = 0.0f;
    };

    class ClientServerTime
    {
        uint32 LastTick = 0;
        uint32 GameTime = 0;
    };

    class ClientLogoutResponse
    {
        int32 LogoutResult = 0;
        bool Instant = false;
    };

    class ClientLogoutComplete
    {
        ObjectGuid SwitchToCharacter;
    };

    class ClientInstanceReset
    {
        uint32 MapID = 0;
    };

    class ClientInstanceResetFailed
    {
        ResetFailedReason ResetFailedReason;
        uint32 MapID = 0;
    };

    class ClientUpdateLastInstance
    {
        uint32 MapID = 0;
    };

    class ClientKickReason
    {
        uint8 Reason = 0;
    };

    class ClientGMChangePVPRating
    {
        bool Success = false;
    };

    class ClientCalendarSendCalendarInviteInfo
    {
        uint64 EventID = 0;
        uint64 InviteID = 0;
        ObjectGuid InviterGUID;
        uint8 Status = 0;
        uint8 Moderator = 0;
        uint8 InviteType = 0;
    };

    class ClientCalendarSendCalendarEventInfo
    {
        uint64 EventID = 0;
        std::string EventName;
        uint8 EventType = 0;
        uint32 Date = 0;
        uint32 Flags = 0;
        int32 TextureID = 0;
        ObjectGuid EventGuildID;
        ObjectGuid OwnerGUID;
    };

    class ClientCalendarSendCalendarRaidLockoutInfo
    {
        uint64 InstanceID = 0;
        int32 MapID = 0;
        uint32 DifficultyID = 0;
        int32 ExpireTime = 0;
    };

    class ClientCalendarSendCalendarRaidResetInfo
    {
        int32 MapID = 0;
        uint32 Duration = 0;
        int32 Offset = 0;
    };

    class ClientCalendarSendCalendarHolidayInfo
    {
        int32 HolidayID = 0;
        int32 Region = 0;
        int32 Looping = 0;
        int32 Priority = 0;
        int32 FilterType = 0;
        std::string TextureFilename;
        int32 Date[26] = { };
        int32 Duration[10] = { };
        int32 CalendarFlags[10] = { };
    };

    class ClientCalendarSendCalendar
    {
        std::vector<ClientCalendarSendCalendarEventInfo> Events;
        std::vector<ClientCalendarSendCalendarRaidResetInfo> RaidResets;
        std::vector<ClientCalendarSendCalendarRaidLockoutInfo> RaidLockouts;
        std::vector<ClientCalendarSendCalendarHolidayInfo> Holidays;
        time_t RaidOrigin = time_t(0);
        std::vector<ClientCalendarSendCalendarInviteInfo> Invites;
        uint32 ServerTime = 0;
        time_t ServerNow = time_t(0);
    };

    class ClientCalendarEventInviteInfo
    {
        ObjectGuid Guid;
        uint64 InviteID = 0;
        uint8 Level = 0;
        uint8 Status = 0;
        uint8 Moderator = 0;
        uint8 InviteType = 0;
        uint32 ResponseTime = 0;
        std::string Notes;
    };

    class ClientCalendarSendEvent
    {
        ObjectGuid OwnerGUID;
        uint32 Date = 0;
        uint32 LockDate = 0;
        uint8 GetEventType = 0;
        std::string Description;
        std::string EventName;
        int32 TextureID = 0;
        uint32 Flags = 0;
        uint8 EventType = 0;
        std::vector<ClientCalendarEventInviteInfo> Invites;
        ObjectGuid EventGuildID;
        uint64 EventID = 0;
    };

    class CalendarEventInitialInviteInfo
    {
        ObjectGuid InviteGUID;
        uint8 Level = 0;
    };

    class ClientCalendarEventInitialInvites
    {
        std::vector<CalendarEventInitialInviteInfo> Invites;
    };

    class ClientCalendarEventInvite
    {
        uint64 InviteID = 0;
        uint32 ResponseTime = 0;
        uint8 Level = 0;
        ObjectGuid InviteGUID;
        uint64 EventID = 0;
        uint8 Type = 0;
        bool ClearPending = false;
        uint8 Status = 0;
    };

    class ClientCalendarEventInviteAlert
    {
        uint8 Status = 0;
        ObjectGuid OwnerGUID;
        uint8 ModeratorStatus = 0;
        ObjectGuid EventGuildID;
        ObjectGuid InvitedByGUID;
        uint32 Flags = 0;
        std::string EventName;
        int32 TextureID = 0;
        uint64 InviteID = 0;
        uint8 EventType = 0;
        uint64 EventID = 0;
        uint32 Date = 0;
    };

    class ClientCalendarEventInviteStatus
    {
        uint32 Flags = 0;
        uint64 EventID = 0;
        uint8 Status = 0;
        bool ClearPending = false;
        uint32 ResponseTime = 0;
        uint32 Date = 0;
        ObjectGuid InviteGUID;
    };

    class ClientCalendarEventInviteStatusAlert
    {
        uint64 EventID = 0;
        uint32 Flags = 0;
        uint32 Date = 0;
        uint8 Status = 0;
    };

    class ClientCalendarEventInviteModeratorStatus
    {
        uint8 Status = 0;
        ObjectGuid InviteGUID;
        uint64 EventID = 0;
        bool ClearPending = false;
    };

    class ClientCalendarEventInviteRemoved
    {
        bool ClearPending = false;
        uint32 Flags = 0;
        ObjectGuid InviteGUID;
        uint64 EventID = 0;
    };

    class ClientCalendarEventInviteRemovedAlert
    {
        uint64 EventID = 0;
        uint32 Date = 0;
        uint32 Flags = 0;
        uint8 Status = 0;
    };

    class ClientCalendarEventRemovedAlert
    {
        uint64 EventID = 0;
        bool ClearPending = false;
        uint32 Date = 0;
    };

    class ClientCalendarEventUpdatedAlert
    {
        uint8 EventType = 0;
        uint32 OriginalDate = 0;
        bool ClearPending = false;
        uint64 EventID = 0;
        std::string Description;
        uint32 Flags = 0;
        int32 TextureID = 0;
        std::string EventName;
        uint32 LockDate = 0;
        uint32 Date = 0;
    };

    class ClientCalendarEventInviteNotes
    {
        ObjectGuid InviteGUID;
        bool ClearPending = false;
        std::string Notes;
        uint64 EventID = 0;
    };

    class ClientCalendarEventInviteNotesAlert
    {
        uint64 EventID = 0;
        std::string Notes;
    };

    class ClientCalendarRaidLockoutAdded
    {
        uint64 InstanceID = 0;
        uint32 DifficultyID = 0;
        int32 TimeRemaining = 0;
        uint32 ServerTime = 0;
        int32 MapID = 0;
    };

    class ClientCalendarRaidLockoutRemoved
    {
        uint64 InstanceID = 0;
        int32 MapID = 0;
        uint32 DifficultyID = 0;
    };

    class ClientCalendarRaidLockoutUpdated
    {
        int32 MapID = 0;
        int32 OldTimeRemaining = 0;
        uint32 ServerTime = 0;
        uint32 DifficultyID = 0;
        int32 NewTimeRemaining = 0;
    };

    class ClientCalendarSendNumPending
    {
        uint32 NumPending = 0;
    };

    class ClientCalendarCommandResult
    {
        std::string Name;
        uint8 Command = 0;
        uint8 Result = 0;
    };

    class ClientSpecialMountAnim
    {
        ObjectGuid UnitGUID;
    };

    class ClientPetActionSound
    {
        ObjectGuid UnitGUID;
        int32 Action = 0;
    };

    class ClientPetDismissSound
    {
        int32 ModelID = 0;
        Vector3 ModelPosition;
    };

    class ClientGMTicketStatusUpdate
    {
        int32 StatusInt = 0;
    };

    class ClientGMTicketUpdate
    {
        uint8 Result = 0;
    };

    class ClientGMTicketResponse
    {
        uint32 ResponseID = 0;
        std::string Description;
        uint32 TicketID = 0;
        std::string ResponseText;
    };

    class ClientGMTicketSystemStatus
    {
        int32 Status = 0;
    };

    class ClientGMTicketCaseStatus
    {
        time_t OldestTicketTime = time_t(0);
        time_t UpdateTime = time_t(0);
        std::vector<GMTicketCase> Cases;
    };

    class ClientSetDungeonDifficulty
    {
        uint32 DifficultyID = 0;
    };

    class ClientWhoIs
    {
        std::string AccountName;
    };

    class ClientWeather
    {
        bool Abrupt = false;
        float int32ensity = 0.0f;
        uint32 WeatherID = 0;
    };

    class ClientUpdateInstanceOwnership
    {
        int32 IOwnInstance = 0;
    };

    class ClientNotifyMissileTrajectoryCollision
    {
        ObjectGuid Caster;
        Vector3 CollisionPos;
        uint8 CastID = 0;
    };

    class ClientInvalidatePlayer
    {
        ObjectGuid Guid;
    };

    class ClientComplaintResult
    {
        uint32 ComplaintType = 0;
        uint8 Result = 0;
    };

    class ClientGMShowComplaints
    {
        std::string Summary;
    };

    class ClientTargetThreat
    {
        ObjectGuid TargetGUID;
        uint32 Threat = 0;
    };

    class ClientListTargets
    {
        ObjectGuid UnitGUID;
        std::vector<ClientTargetThreat> Targets;
    };

    class ClientReportPvPPlayerAFKResult
    {
        ObjectGuid Offender;
        uint8 NumPlayersIHaveReported = 0;
        uint8 NumBlackMarksOnOffender = 0;
        uint8 Result = 0;
    };

    class ClientDismount
    {
        ObjectGuid Guid;
    };

    class ClientClearTarget
    {
        ObjectGuid Guid;
    };

    class ClientEquipmentSetID
    {
        ObjectGuid GUID;
        int32 SetID = 0;
    };

    class ClientCastFailed
    {
        int32 FailedArg2 = 0;
        int32 Reason = 0;
        int32 FailedArg1 = 0;
        int32 SpellID = 0;
        uint8 CastID = 0;
    };

    class ClientPetCastFailed
    {
        int32 Reason = 0;
        int32 FailedArg2 = 0;
        int32 FailedArg1 = 0;
        int32 SpellID = 0;
        uint8 CastID = 0;
    };

    class ClientPetTameFailure
    {
        uint8 Result = 0;
    };

    class ClientServerInfoQueryResponse
    {
        std::string Response;
    };

    class ClientAIReaction
    {
        ObjectGuid UnitGUID;
        int32 Reaction = 0;
    };

    class ClientOfferPetitionError
    {
        ObjectGuid PlayerGUID;
    };

    class ClientConvertRune
    {
        uint8 Rune = 0;
        uint8 Index = 0;
    };

    class ClientAddRunePower
    {
        uint32 AddedRunesMask = 0;
    };

    class ClientRealmSplit
    {
        int32 Decision = 0;
        int32 State = 0;
        std::string Date;
    };

    class ClientCooldownEvent
    {
        ObjectGuid CasterGUID;
        int32 SpellID = 0;
    };

    class ClientClearCooldown
    {
        bool ClearOnHold = false;
        ObjectGuid CasterGUID;
        int32 SpellID = 0;
    };

    class ClientRealmQueryResponse
    {
        uint32 VirtualRealmAddress = 0;
        uint8 LookupState = 0;
        VirtualRealmNameInfo NameInfo;
    };

    class ClientOverrideLight
    {
        int32 TransitionMilliseconds = 0;
        int32 AreaLightID = 0;
        int32 OverrideLightID = 0;
    };

    class ClientBarberShopResult
    {
        int32 Result = 0;
    };

    class ClientPetitionShowList
    {
        ObjectGuid Unit;
        uint32 Price = 0;
    };

    class PetitionSignature
    {
        ObjectGuid Signer;
        int32 Choice = 0;
    };

    class ClientPetitionShowSignatures
    {
        std::vector<PetitionSignature> Signatures;
        int32 PetitionID = 0;
        ObjectGuid Item;
        ObjectGuid Owner;
    };

    class ClientReferAFriendFailure
    {
        std::string Str;
        int32 Reason = 0;
    };

    class ClientCrossedInebriationThreshold
    {
        ObjectGuid Guid;
        int32 ItemID = 0;
        int32 Threshold = 0;
    };

    class ClientForceActionShowResponse
    {
        uint32 DebugCombatVictimActions = 0;
        uint32 DebugCombatActions = 0;
    };

    class ClientPetNameInvalid
    {
        PetRenameData RenameData;
        uint8 Result = 0;
    };

    class ClientSellResponse
    {
        ObjectGuid VendorGUID;
        ObjectGuid ItemGUID;
        uint8 Reason = 0;
    };

    class ClientBuySucceeded
    {
        ObjectGuid VendorGUID;
        uint32 Muid = 0;
        uint32 QuantityBought = 0;
        int32 NewQuantity = 0;
    };

    class ClientBuyFailed
    {
        ObjectGuid VendorGUID;
        uint32 Muid = 0;
        uint8 Reason = 0;
    };

    class ClientTotemCreated
    {
        ObjectGuid Totem;
        int32 SpellID = 0;
        int32 Duration = 0;
        uint8 Slot = 0;
    };

    class ClientTotemMoved
    {
        ObjectGuid Totem;
        uint8 Slot = 0;
        uint8 NewSlot = 0;
    };

    class ClientTriggerMovie
    {
        uint32 MovieID = 0;
    };

    class ClientDynamicDropRollResult
    {
        uint8 DynamicDropResult = 0;
        float Roll = 0.0f;
        float Chance = 0.0f;
        ObjectGuid LosingPlayerGUID;
        uint32 BiggestLosingStreak = 0;
        uint32 ItemID = 0;
    };

    class ClientShowTaxiNodesWindowInfo
    {
        ObjectGuid UnitGUID;
        int32 CurrentNode = 0;
    };

    class ClientShowTaxiNodes
    {
        Optional<ClientShowTaxiNodesWindowInfo> WindowInfo;
        std::vector<uint8> Nodes;
    };

    class ClientMinimapPing
    {
        ObjectGuid Sender;
        Vector2 Position;
    };

    class ClientQueryCreatureResponse
    {
        bool Allow = false;
        CliCreatureStats Stats;
        uint32 CreatureID = 0;
    };

    class ClientQueryGameObjectResponse
    {
        uint32 GameObjectID = 0;
        bool Allow = false;
        Data Stats;
    };

    class ClientHealthUpdate
    {
        ObjectGuid Guid;
        int32 Health = 0;
    };

    class ClientPowerUpdatePower
    {
        int32 Power = 0;
        uint8 PowerType = 0;
    };

    class ClientPowerUpdate
    {
        std::vector<ClientPowerUpdatePower> Powers;
        ObjectGuid Guid;
    };

    class ClientQueryNPCTextResponse
    {
        uint32 TextID = 0;
        bool Allow = false;
        Data NpcText;
    };

    class ClientQueryPlayerNameResponse
    {
        ObjectGuid Player;
        uint8 Result = 0;
        PlayerGuidLookupData Data;
    };

    class CliPageTextInfo
    {
        uint32 ID = 0;
        uint32 NextPageID = 0;
        std::string Text;
    };

    class ClientQueryPageTextResponse
    {
        bool Allow = false;
        CliPageTextInfo Info;
        uint32 PageTextID = 0;
    };

    class ClientQueryPetNameResponse
    {
        ObjectGuid PetID;
        bool Allow = false;
        std::string Name;
        bool HasDeclined = false;
        time_t Timestamp = time_t(0);
        std::string DeclinedNames[5] = { };
    };

    class ClientQueryBattlePetNameResponse
    {
        ObjectGuid BattlePetID;
        int32 CreatureID = 0;
        bool Allow = false;
        std::string Name;
        bool HasDeclined = false;
        std::string DeclinedNames[5] = { };
        time_t Timestamp = time_t(0);
    };

    class ClientQueryPetitionResponse
    {
        uint32 PetitionID = 0;
        bool Allow = false;
        CliPetitionInfo Info;
    };

    class ClientDeathReleaseLoc
    {
        Vector3 Loc;
        int32 MapID = 0;
    };

    class ClientSetPlayerDeclinedNamesResult
    {
        ObjectGuid Player;
        int32 ResultCode = 0;
    };

    class ClientPlayedTime
    {
        int32 TotalTime = 0;
        bool TriggerEvent = false;
        int32 LevelTime = 0;
    };

    class ClientScriptMessage
    {
        std::string Text;
    };

    class ClientTitleEarned
    {
        int32 Index = 0;
    };

    class ClientTitleLost
    {
        int32 Index = 0;
    };

    class ThreatInfo
    {
        ObjectGuid UnitGUID;
        int32 Threat = 0;
    };

    class ClientHighestThreatUpdate
    {
        ObjectGuid UnitGUID;
        std::vector<ThreatInfo> ThreatList;
        ObjectGuid HighestThreatGUID;
    };

    class ClientThreatUpdate
    {
        ObjectGuid UnitGUID;
        std::vector<ThreatInfo> ThreatList;
    };

    class ClientThreatRemove
    {
        ObjectGuid AboutGUID;
        ObjectGuid UnitGUID;
    };

    class ClientThreatClear
    {
        ObjectGuid UnitGUID;
    };

    class ClientProposeLevelGrant
    {
        ObjectGuid Sender;
    };

    class ClientArenaError
    {
        ArenaErrorType ErrorType;
        uint8 TeamSize = 0;
    };

    class ClientLFGOfferContinue
    {
        uint32 Slot = 0;
    };

    class ClientCancelAutoRepeat
    {
        ObjectGuid Guid;
    };

    class ClientResetRangedCombatTimer
    {
        int32 Delay = 0;
    };

    class ClientTrainerListSpell
    {
        int32 SpellID = 0;
        uint32 MoneyCost = 0;
        uint32 ReqSkillLine = 0;
        uint32 ReqSkillRank = 0;
        int32 ReqAbility[3] = { };
        uint8 Usable = 0;
        uint8 ReqLevel = 0;
    };

    class ClientTrainerList
    {
        std::string Greeting;
        int32 TrainerType = 0;
        ObjectGuid TrainerGUID;
        int32 TrainerID = 0;
        std::vector<ClientTrainerListSpell> Spells;
    };

    class ClientTrainerBuyFailed
    {
        ObjectGuid TrainerGUID;
        int32 TrainerFailedReason = 0;
        int32 SpellID = 0;
    };

    class ClientPVPCredit
    {
        ObjectGuid Target;
        int32 Honor = 0;
        int32 Rank = 0;
    };

    class ClientCriteriaUpdate
    {
        Data CurrentTime;
        int32 Flags = 0;
        uint64 Quantity = 0;
        ObjectGuid PlayerGUID;
        int32 CriteriaID = 0;
        time_t ElapsedTime = time_t(0);
        time_t CreationTime = time_t(0);
    };

    class ClientCharCustomize
    {
        uint8 Result = 0;
        uint8 HairStyleID = 0;
        uint8 SexID = 0;
        uint8 FaceID = 0;
        std::string CharName;
        uint8 HairColorID = 0;
        uint8 SkinID = 0;
        uint8 FacialHairStyleID = 0;
        ObjectGuid CharGUID;
    };

    class ClientQueryTimeResponse
    {
        time_t CurrentTime = time_t(0);
        int32 TimeOutRequest = 0;
    };

    class ClientLogXPGain
    {
        int32 Amount = 0;
        float GroupBonus = 0.0f;
        uint8 Reason = 0;
        bool ReferAFriend = false;
        int32 Original = 0;
        ObjectGuid Victim;
    };

    class ClientCriteriaDeleted
    {
        int32 CriteriaID = 0;
    };

    class ClientAchievementDeleted
    {
        int32 Immunities = 0;
        int32 AchievementID = 0;
    };

    class ClientLevelUpInfo
    {
        int32 Cp = 0;
        int32 StatDelta[5] = { };
        int32 HealthDelta = 0;
        int32 PowerDelta[6] = { };
        int32 Level = 0;
    };

    class DebugAIState
    {
        std::string DebugState;
    };

    class ClientDebugAIState
    {
        std::vector<DebugAIState> DebugStates;
        ObjectGuid Guid;
    };

    class ClientAuctionHelloResponse
    {
        ObjectGuid Auctioneer;
        bool OpenForBusiness = false;
    };

    class ClientAuctionReplicateResponse
    {
        uint32 ChangeNumberCursor = 0;
        uint32 ChangeNumberGlobal = 0;
        uint32 DesiredDelay = 0;
        uint32 ChangeNumberTombstone = 0;
        uint32 Result = 0;
        std::vector<CliAuctionItem> Items;
    };

    class ClientAuctionCommandResult
    {
        ObjectGuid Guid;
        uint64 MinIncrement = 0;
        uint64 Money = 0;
        int32 ErrorCode = 0;
        int32 AuctionItemID = 0;
        int32 BagResult = 0;
        int32 Command = 0;
    };

    class ClientAuctionBidderNotification
    {
        int32 AuctionItemID = 0;
        ObjectGuid Bidder;
        ItemInstance Item;
    };

    class ClientAuctionWonNotification
    {
        ClientAuctionBidderNotification Info;
    };

    class ClientAuctionOutbidNotification
    {
        ClientAuctionBidderNotification Info;
        uint64 BidAmount = 0;
        uint64 MinIncrement = 0;
    };

    class ClientAuctionOwnerNotification
    {
        int32 AuctionItemID = 0;
        uint64 BidAmount = 0;
        ItemInstance Item;
    };

    class ClientAuctionClosedNotification
    {
        ClientAuctionOwnerNotification Info;
        float ProceedsMailDelay = 0.0f;
        bool Sold = false;
    };

    class ClientAuctionOwnerBidNotification
    {
        ClientAuctionOwnerNotification Info;
        ObjectGuid Bidder;
        uint64 MinIncrement = 0;
    };

    class ClientAuctionListItemsResult
    {
        uint32 DesiredDelay = 0;
        std::vector<CliAuctionItem> Items;
        bool OnlyUsable = false;
        uint32 TotalCount = 0;
    };

    class ClientAuctionListOwnerItemsResult
    {
        uint32 DesiredDelay = 0;
        std::vector<CliAuctionItem> Items;
        uint32 TotalCount = 0;
    };

    class ClientAuctionListBidderItemsResult
    {
        uint32 DesiredDelay = 0;
        std::vector<CliAuctionItem> Items;
        uint32 TotalCount = 0;
    };

    class ClientAuctionListPendingSalesResult
    {
        std::vector<CliMailListEntry> Mails;
        int32 TotalNumRecords = 0;
    };

    class ClientServerBuckDataStart
    {
        uint32 RequestID = 0;
        uint8 Mpid = 0;
        uint8 NumVServers = 0;
    };

    class ClientSetVehicleRecID
    {
        ObjectGuid VehicleGUID;
        int32 VehicleRecID = 0;
    };

    class ClientPendingRaidLock
    {
        uint32 CompletedMask = 0;
        bool WarningOnly = false;
        int32 TimeUntilLock = 0;
        bool Extending = false;
    };

    class ClientSpellFailure
    {
        ObjectGuid CasterUnit;
        int32 SpellID = 0;
        uint8 Reason = 0;
        uint8 CastID = 0;
    };

    class ClientDestructibleBuildingDamage
    {
        ObjectGuid Target;
        ObjectGuid Caster;
        ObjectGuid Owner;
        int32 Damage = 0;
        int32 SpellID = 0;
    };

    class ClientAttackSwingError
    {
        Attackswingerr Reason;
    };

    class ClientAttackSwingLandedLog
    {
        SpellCastLogData LogData;
        Data AttackRoundInfo;
    };

    class ClientChangePlayerDifficultyResult
    {
        SetPlayerDifficultyResults Result;
        int32 DifficultyRecID = 0;
        int32 MapID = 0;
        int32 InstanceDifficultyID = 0;
        DifficultyCooldownReason CooldownReason;
        time_t Cooldown = time_t(0);
        ObjectGuid Guid;
    };

    class ClientInstanceGroupSizeChanged
    {
        uint32 GroupSize = 0;
    };

    class ClientServerBuckData
    {
        uint8 ClusterID = 0;
        int32 CaptureTime = 0;
        uint32 RequestID = 0;
        std::vector<ServerBuckDataList> Data;
    };

    class ClientGodMode
    {
        bool Enabled = false;
    };

    class ClientBinderConfirm
    {
        ObjectGuid Unit;
    };

    class ClientPlayTimeWarning
    {
        uint32 Flags = 0;
        int32 Remaining = 0;
    };

    class ClientGMDestroyCorpse
    {
        bool Success = false;
    };

    class ClientSetFactionAtWar
    {
        uint8 FactionIndex = 0;
        uint8 Flags = 0;
    };

    class ResyncRune
    {
        uint8 RuneType = 0;
        uint8 Cooldown = 0;
    };

    class ClientResyncRunes
    {
        std::vector<ResyncRune> Runes;
    };

    class ClientCreateChar
    {
        uint8 Code = 0;
    };

    class ClientDeleteChar
    {
        uint8 Code = 0;
    };

    class ClientTransferAborted
    {
        TransferAbort TransfertAbort;
        uint8 Arg = 0;
        uint32 MapID = 0;
    };

    class ClientPetGUIDs
    {
        std::vector<ObjectGuid> PetGUIDs;
    };

    class ClientCacheVersion
    {
        uint32 CacheVersion = 0;
    };

    class ClientCharacterLoginFailed
    {
        uint8 Code = 0;
    };

    class ClientCommentatorStateChanged
    {
        bool Enable = false;
        ObjectGuid Guid;
    };

    class CommentatorPlayer
    {
        ObjectGuid Guid;
        ServerSpec UserServer;
    };

    class CommentatorTeam
    {
        ObjectGuid Guid;
        std::vector<CommentatorPlayer> Players;
    };

    class CommentatorInstance
    {
        uint32 MapID = 0;
        ServerSpec WorldServer;
        uint64 InstanceID = 0;
        uint32 Status = 0;
        CommentatorTeam Teams[2] = { };
    };

    class CommentatorMap
    {
        uint32 TeamSize = 0;
        uint32 MinLevelRange = 0;
        uint32 MaxLevelRange = 0;
        int32 DifficultyID = 0;
        std::vector<CommentatorInstance> Instances;
    };

    class ClientCommentatorMapInfo
    {
        ObjectGuid PlayerInstanceID;
        std::vector<CommentatorMap> Maps;
    };

    class CommentatorPlayerInfo
    {
        ObjectGuid PlayerGUID;
        uint32 DamageDone = 0;
        uint32 DamageTaken = 0;
        uint32 HealingDone = 0;
        uint32 HealingTaken = 0;
        uint16 Kills = 0;
        uint16 Deaths = 0;
        int8 Faction = 0;
    };

    class ClientCommentatorPlayerInfo
    {
        uint32 MapID = 0;
        std::vector<CommentatorPlayerInfo> PlayerInfo;
        uint64 InstanceID = 0;
        ServerSpec WorldServer;
    };

    class ClientUpdateAccountData
    {
        ObjectGuid Player;
        time_t Time = time_t(0);
        uint32 Size = 0;
        uint8 DataType = 0;
        Data CompressedData;
    };

    class ClientAccountDataTimes
    {
        time_t ServerTime = time_t(0);
        uint32 TimeBits = 0;
        long AccountTimes[8] = { };
    };

    class ClientGameTimeUpdate
    {
        int32 GameTimeHolidayOffset = 0;
        int32 ServerTimeHolidayOffset = 0;
        uint32 GameTime = 0;
        uint32 ServerTime = 0;
    };

    class ClientGameTimeSet
    {
        uint32 ServerTime = 0;
        int32 GameTimeHolidayOffset = 0;
        int32 ServerTimeHolidayOffset = 0;
        uint32 GameTime = 0;
    };

    class ClientLoginSetTimeSpeed
    {
        float NewSpeed = 0.0f;
        int32 ServerTimeHolidayOffset = 0;
        uint32 GameTime = 0;
        uint32 ServerTime = 0;
        int32 GameTimeHolidayOffset = 0;
    };

    class ClientLoadEquipmentSet
    {
        std::vector<EquipmentSetData> SetData;
    };

    class ClientStartMirrorTimer
    {
        int32 Scale = 0;
        int32 MaxValue = 0;
        int32 Timer = 0;
        int32 SpellID = 0;
        int32 Value = 0;
        bool Paused = false;
    };

    class ClientPauseMirrorTimer
    {
        bool Paused = false;
        int32 Timer = 0;
    };

    class ClientStopMirrorTimer
    {
        int32 Timer = 0;
    };

    class ClientCorpseTransportQuery
    {
        Vector3 Position;
        float Facing = 0.0f;
    };

    class ClientEnchantmentLog
    {
        ObjectGuid Caster;
        ObjectGuid Owner;
        ObjectGuid ItemGUID;
        int32 ItemID = 0;
        int32 EnchantSlot = 0;
        int32 Enchantment = 0;
    };

    class ClientGMTicketResolveResponse
    {
        bool ShowSurvey = false;
    };

    class ClientUITime
    {
        time_t Time = time_t(0);
    };

    class ClientSpiritHealerConfirm
    {
        ObjectGuid Unit;
    };

    class ClientTalentsInvoluntarilyReset
    {
        bool IsPetTalents = false;
    };

    class ClientPageText
    {
        ObjectGuid GameObjectGUID;
    };

    class ClientStandStateUpdate
    {
        uint8 State = 0;
    };

    class ForcedReaction
    {
        int32 Faction = 0;
        int32 Reaction = 0;
    };

    class ClientSetForcedReactions
    {
        std::vector<ForcedReaction> Reactions;
    };

    class ClientSpellFailedOther
    {
        ObjectGuid CasterUnit;
        int32 SpellID = 0;
        uint8 Reason = 0;
        uint8 CastID = 0;
    };

    class ClientGameObjectResetState
    {
        ObjectGuid ObjectGUID;
    };

    class ClientGMPhaseDump
    {
        PhaseShiftData PhaseShift;
        ObjectGuid Target;
    };

    class ClientGMSpawnTrackerDump
    {
        ObjectGuid Target;
        SpawnTrackerData SpawnTrackerData;
    };

    class ClientSummonRequest
    {
        ObjectGuid SummonerGUID;
        uint32 SummonerVirtualRealmAddress = 0;
        int32 AreaID = 0;
    };

    class ClientInspectPVP
    {
        std::vector<PVPBracketData> Bracket;
        ObjectGuid ClientGUID;
    };

    class ClientReferAFriendExpired
    {
        ObjectGuid UnlinkedFriend;
    };

    class ClientInventoryChangeFailure
    {
        int8 BagResult = 0;
        uint8 ContainerBSlot = 0;
        ObjectGuid SrcContainer;
        ObjectGuid DstContainer;
        int32 SrcSlot = 0;
        int32 LimitCategory = 0;
        int32 Level = 0;
        ObjectGuid Item[2] = { };
    };

    class ClientOpenContainer
    {
        ObjectGuid Container;
    };

    class ClientInitializeFactions
    {
        int32 FactionStandings[256] = { };
        bool FactionHasBonus[256] = { };
        uint8 FactionFlags[256] = { };
    };

    class ClientFactionBonusInfo
    {
        bool FactionHasBonus[256] = { };
    };

    class ClientCameraShake
    {
        int32 SoundID = 0;
        int32 CameraShakeID = 0;
    };

    class ClientSocketGems
    {
        ObjectGuid Item;
        int32 Sockets[3] = { };
        int32 SocketMatch = 0;
    };

    class ClientGmSilence
    {
        bool Silenced = false;
        bool Success = false;
    };

    class ClientSetFactionVisible
    {
        int32 FactionIndex = 0;
    };

    class ClientSetFactionNotVisible
    {
        int32 FactionIndex = 0;
    };

    class FactionStandingData
    {
        int32 Index = 0;
        int32 Standing = 0;
    };

    class ClientSetFactionStanding
    {
        std::vector<FactionStandingData> Faction;
        float BonusFromAchievementSystem = 0.0f;
        float ReferAFriendBonus = 0.0f;
        bool ShowVisual = false;
    };

    class ClientGmRevealTo
    {
        bool Success = false;
    };

    class ClientSetAIAnimKit
    {
        ObjectGuid Unit;
        uint16 AnimKitID = 0;
    };

    class ClientPlayOneShotAnimKit
    {
        ObjectGuid Unit;
        uint16 AnimKitID = 0;
    };

    class ClientSetMovementAnimKit
    {
        ObjectGuid Unit;
        uint16 AnimKitID = 0;
    };

    class ClientSetMeleeAnimKit
    {
        ObjectGuid Unit;
        uint16 AnimKitID = 0;
    };

    class ClientSetAnimTier
    {
        ObjectGuid Unit;
        int32 Tier = 0;
    };

    class ClientSetProficiency
    {
        uint32 ProficiencyMask = 0;
        uint8 ProficiencyClass = 0;
    };

    class ClientCheatPlayerLookup
    {
        uint8 ExperienceLevel = 0;
        uint8 FaceID = 0;
        uint32 Flags = 0;
        uint32 Flags3 = 0;
        uint8 RaceID = 0;
        uint32 ZoneID = 0;
        uint32 PetExperienceLevel = 0;
        uint8 FirstLogin = 0;
        uint8 SexID = 0;
        uint8 HairStyleID = 0;
        uint32 MapID = 0;
        uint8 ClassID = 0;
        ObjectGuid Guid;
        Vector3 Position;
        uint32 PetCreatureFamilyID = 0;
        std::string Name;
        uint8 HairColorID = 0;
        uint8 SkinID = 0;
        uint32 PetDisplayInfoID = 0;
        ObjectGuid GuildGUID;
        uint32 Flags2 = 0;
        uint8 FacialHairStyleID = 0;
    };

    class ClientGmPlayerInfo
    {
        std::string CharName;
        uint32 MapID = 0;
        uint32 AreaID = 0;
        Vector3 Position;
        float Facing = 0.0f;
        std::string AccountName;
        uint32 Seconds = 0;
        uint32 Hours = 0;
        uint32 Minutes = 0;
        uint32 Level = 0;
        uint32 Race = 0;
        std::string GuildName;
        uint32 Cls = 0;
        std::string FullName;
        ObjectGuid CharGUID;
    };

    class ClientCooldownCheat
    {
        ObjectGuid Guid;
    };

    class ClientGmCharacterSaveSuccess
    {
        Data ProfileData;
    };

    class AddonInfo
    {
        uint8 Status = 0;
        bool InfoProvided = false;
        bool KeyProvided = false;
        bool UrlProvided = false;
        uint8 KeyVersion = 0;
        uint32 Revision = 0;
        std::string Url;
        int8 KeyData[256] = { };
    };

    class BannedAddonInfo
    {
        int32 Id = 0;
        time_t LastModified = time_t(0);
        int32 Flags = 0;
        uint32 NameMD5[4] = { };
        uint32 VersionMD5[4] = { };
    };

    class ClientAddonInfo
    {
        std::vector<BannedAddonInfo> BannedAddons;
        std::vector<AddonInfo> Addons;
    };

    class ClientGMNamedPointsData
    {
        ObjectGuid Transport;
        Vector3 Position;
        float Facing = 0.0f;
        std::string int32ernalName;
        std::string Name;
    };

    class ClientGmNamedPoints
    {
        std::vector<ClientGMNamedPointsData> NamedPoints;
    };

    class ClientGMGearRatingResponse
    {
        float GearRating = 0.0f;
    };

    class ClientAreaSpiritHealerTime
    {
        ObjectGuid HealerGuid;
        int32 TimeLeft = 0;
    };

    class ClientLootList
    {
        Optional<ObjectGuid> RoundRobinWinner;
        Optional<ObjectGuid> Master;
        ObjectGuid Owner;
    };

    class ClientDestroyArenaUnit
    {
        ObjectGuid Guid;
    };

    class ClientPlayerSkinned
    {
        bool FreeRepop = false;
    };

    class ClientProfileDataResponse
    {
        uint8 PerfData[488] = { };
    };

    class ClientDurabilityDamageDeath
    {
        int32 Percent = 0;
    };

    class ClientWorldStateInfo
    {
        int32 VariableID = 0;
        int32 Value = 0;
    };

    class ClientInitWorldStates
    {
        std::vector<ClientWorldStateInfo> Worldstates;
        int32 AreaID = 0;
        int32 SubareaID = 0;
        int32 MapID = 0;
    };

    class ClientUpdateWorldState
    {
        int32 Value = 0;
        bool Hidden = false;
        int32 VariableID = 0;
    };

    class ClientPetActionFeedback
    {
        int32 SpellID = 0;
        uint8 Response = 0;
    };

    class ClientCorpseReclaimDelay
    {
        uint32 Remaining = 0;
    };

    class ClientPetitionSignResults
    {
        ObjectGuid Player;
        PetitionError Error;
        ObjectGuid Item;
    };

    class ClientPetitionDeclined
    {
        ObjectGuid Decliner;
    };

    class ClientTurnInPetitionResult
    {
        PetitionError Result;
    };

    class ClientUseEquipmentSetResult
    {
        uint8 Reason = 0;
    };

    class ClientDumpObjectsData
    {
        std::vector<DumpObjectInfo> ObjectInfo;
    };

    class ClientForceAnim
    {
        std::string Arguments;
        ObjectGuid Target;
    };

    class ClientItemTimeUpdate
    {
        ObjectGuid ItemGuid;
        uint32 DurationLeft = 0;
    };

    class ClientItemEnchantTimeUpdate
    {
        ObjectGuid OwnerGuid;
        ObjectGuid ItemGuid;
        uint32 DurationLeft = 0;
        int32 Slot = 0;
    };

    class ClientMailListResult
    {
        int32 TotalNumRecords = 0;
        std::vector<CliMailListEntry> Mails;
    };

    class ClientMailQueryNextTimeResult
    {
        std::vector<CliMailNextTimeEntry> Next;
        float NextMailTime = 0.0f;
    };

    class ClientPartyMemberState
    {
        uint32 ChangeMask = 0;
        ObjectGuid MemberGuid;
        bool ForEnemy = false;
        bool FullUpdate = false;
        Data Changes;
    };

    class ClientPlayerSaveGuildEmblem
    {
        int32 Error = 0;
    };

    class ClientPlayerTabardVendorActivate
    {
        ObjectGuid Vendor;
    };

    class ClientPartyKillLog
    {
        ObjectGuid Victim;
        ObjectGuid Player;
    };

    class ClientProcResist
    {
        ObjectGuid Target;
        Optional<float> Needed;
        int32 SpellID = 0;
        Optional<float> Rolled;
        ObjectGuid Caster;
    };

    class ClientBattlegroundPoints
    {
        uint16 Points = 0;
        uint8 Team = 0;
    };

    class ClientBattlegroundInit
    {
        uint16 MaxPoints = 0;
    };

    class ClientMapObjectivesInit
    {
        std::vector<BattlegroundCapturePointInfo> CapturePointInfo;
    };

    class ClientExplorationExperience
    {
        int32 Experience = 0;
        int32 AreaID = 0;
    };

    class ClientLfgBootPlayer
    {
        LfgBootInfo Info;
    };

    class ClientLfgPartyInfo
    {
        std::vector<LFGBlackList> Player;
    };

    class ClientLfgPlayerInfo
    {
        LFGBlackList BlackList;
        std::vector<LfgPlayerDungeonInfo> Dungeon;
    };

    class ClientLFGPlayerReward
    {
        int32 RewardMoney = 0;
        uint32 QueuedSlot = 0;
        std::vector<LFGPlayerRewards> Rewards;
        int32 AddedXP = 0;
        uint32 ActualSlot = 0;
    };

    class ClientDanceStudioCreateResult
    {
        bool Enable = false;
        int32 Secrets[4] = { };
    };

    class ClientGetAccountCharacterListResult
    {
        uint32 Token = 0;
        std::vector<CliAccountCharacterData> Characters;
    };

    class ClientLiveRegionGetAccountCharacterListResult
    {
        bool Success = false;
        std::vector<CliAccountCharacterData> Characters;
        uint32 Token = 0;
    };

    class ClientCharacterRenameResult
    {
        std::string Name;
        uint8 Result = 0;
        Optional<ObjectGuid> Guid;
    };

    class ClientModifyCooldown
    {
        ObjectGuid UnitGUID;
        int32 DeltaTime = 0;
        int32 SpellID = 0;
    };

    class ClientPreRessurect
    {
        ObjectGuid PlayerGUID;
    };

    class ClientNotifyDestLocSpellCast
    {
        NotifyDestLocSpellCastData Data;
    };

    class ClientPlaySound
    {
        ObjectGuid SourceObjectGUID;
        int32 SoundKitID = 0;
    };

    class ClientPlayMusic
    {
        int32 SoundKitID = 0;
    };

    class ClientPlayObjectSound
    {
        ObjectGuid TargetObjectGUID;
        ObjectGuid SourceObjectGUID;
        int32 SoundKitID = 0;
    };

    class ClientLiveRegionCharacterCopyResult
    {
        bool Success = false;
        uint32 Token = 0;
    };

    class ClientVignetteUpdate
    {
        VignetteClientDataSet Updated;
        bool ForceUpdate = false;
        VignetteInstanceIDList Removed;
        VignetteClientDataSet Added;
    };

    class ClientLiveRegionAccountRestoreResult
    {
        uint32 Token = 0;
        bool Success = false;
    };

    class ClientShowTradeSkillResponse
    {
        SkillLineData SkillLineData;
        ObjectGuid PlayerGUID;
    };

    class ClientBattlePayGetProductListResponse
    {
        std::vector<BattlePayProduct> Products;
        uint32 Result = 0;
        std::vector<BattlePayProductGroup> Groups;
        std::vector<BattlePayShopEntry> ShopEntries;
        uint32 CurrencyID = 0;
    };

    class ClientBattlePayGetPurchaseListResponse
    {
        std::vector<BattlePayPurchase> Purchases;
        uint32 Result = 0;
    };

    class ClientBattlePayGetDistributionListResponse
    {
        uint32 Result = 0;
        std::vector<BattlePayDistributionObject> DistributionObjects;
    };

    class ClientBattlePayDistributionUpdate
    {
        BattlePayDistributionObject DistributionObject;
    };

    class ClientBattlePayDeliveryStarted
    {
        uint64 DistributionID = 0;
    };

    class ClientBattlePayDeliveryEnded
    {
        uint64 DistributionID = 0;
        std::vector<ItemInstance> Items;
    };

    class ClientPetitionRenameGuildResponse
    {
        ObjectGuid PetitionGuid;
        std::string NewGuildName;
    };

    class ClientRoleChosen
    {
        bool Accepted = false;
        uint32 RoleMask = 0;
        ObjectGuid Player;
    };

    class ClientInstanceSaveCreated
    {
        bool Gm = false;
    };

    class ClientEncounterStart
    {
        int32 DifficultyID = 0;
        int32 GroupSize = 0;
        int32 EncounterID = 0;
    };

    class ClientEncounterEnd
    {
        int32 GroupSize = 0;
        bool Success = false;
        int32 DifficultyID = 0;
        int32 EncounterID = 0;
    };

    class ClientBattlePayStartPurchaseResponse
    {
        uint64 PurchaseID = 0;
        uint32 PurchaseResult = 0;
        uint32 ClientToken = 0;
    };

    class ClientBattlePayStartDistributionAssignToTargetResponse
    {
        uint64 DistributionID = 0;
        uint32 ClientToken = 0;
        uint32 Result = 0;
    };

    class ClientBattlePayStartDistributionMakeProductChoiceResponse
    {
        uint32 ClientToken = 0;
        ProductChoiceResult Result;
        uint64 DistributionID = 0;
    };

    class ClientBattlePayPurchaseUpdate
    {
        std::vector<BattlePayPurchase> Purchases;
    };

    class ClientBattlePayConfirmPurchase
    {
        uint64 CurrentPriceFixedPoint = 0;
        uint64 PurchaseID = 0;
        uint32 ServerToken = 0;
    };

    class ClientBattlePayAckFailed
    {
        uint64 PurchaseID = 0;
        uint32 Status = 0;
        uint32 Result = 0;
        uint32 ServerToken = 0;
    };

    class ClientConquestFormulaConstants
    {
        float PvpCPExpCoefficient = 0.0f;
        uint32 PvpMaxCPPerWeek = 0;
        uint32 PvpMinCPPerWeek = 0;
        float PvpCPBaseCoefficient = 0.0f;
        float PvpCPNumerator = 0.0f;
    };

    class ClientScriptCast
    {
        int32 SpellID = 0;
    };

    class ClientRAFEmailEnabledResponse
    {
        RafEmailEnabledResponse Result;
    };

    class ClientRecruitAFriendResponse
    {
        RecruitAFriendResult Result;
    };

    class ContactInfo
    {
        ObjectGuid Guid;
        uint32 VirtualRealmAddr = 0;
        uint32 NativeRealmAddr = 0;
        uint32 TypeFlags = 0;
        std::string Notes;
        uint8 Status = 0;
        uint32 AreaID = 0;
        uint32 Level = 0;
        uint32 ClassID = 0;
    };

    class ClientContactList
    {
        std::vector<ContactInfo> Contacts;
        uint32 Flags = 0;
    };

    class ClientFriendStatus
    {
        uint32 VirtualRealmAddress = 0;
        std::string Notes;
        uint32 ClassID = 0;
        uint8 Status = 0;
        ObjectGuid Guid;
        uint32 Level = 0;
        uint32 AreaID = 0;
        uint8 FriendResult = 0;
    };

    class ClientCharacterObjectTestResponse
    {
        int32 Pong = 0;
    };

    class ClientBattlenetChallengeStart
    {
        uint32 Token = 0;
        std::string ChallengeURL;
    };

    class ClientBattlenetChallengeAbort
    {
        uint32 Token = 0;
        bool Timeout = false;
    };

    class ClientAttackerStateUpdate
    {
        Optional<SpellCastLogData> LogData;
        Data AttackRoundInfo;
    };

    class ClientTaskProgress
    {
        uint32 TaskID = 0;
        uint32 FailureTime = 0;
        uint32 Flags = 0;
        std::vector<uint16> Counts;
    };

    class ClientUpdateTaskProgress
    {
        std::vector<ClientTaskProgress> Progress;
    };

    class ClientSetAllTaskProgress
    {
        std::vector<ClientTaskProgress> Progress;
    };

    class ClientSetTaskComplete
    {
        uint32 TaskID = 0;
    };

    class ClientGroupDecline
    {
        std::string Name;
    };

    class ClientPartyCommandResult
    {
        std::string Name;
        uint32 ResultData = 0;
        ObjectGuid ResultGUID;
        uint8 Result = 0;
        uint8 Command = 0;
    };

    class ClientGossipPOI
    {
        int32 Icon = 0;
        Vector2 Pos;
        uint16 Flags = 0;
        int32 Importance = 0;
        std::string Name;
    };

    class GdfSimPlayerResult
    {
        ObjectGuid Guid;
        bool Team = false;
        int32 PreRating = 0;
        int32 PostRating = 0;
        int32 RatingChange = 0;
        float PreGdf = 0.0f;
        float PostGdf = 0.0f;
        float GdfChange = 0.0f;
        int32 PreGdfAsELO = 0;
        int32 PostGdfAsELO = 0;
        int32 GdfChangeAsELO = 0;
        float PreVariance = 0.0f;
        float PostVariance = 0.0f;
        float VarianceChange = 0.0f;
    };

    class PlayerCliGdfSimCheatResult
    {
        std::vector<GdfSimPlayerResult> Players;
        int32 PreMMR[2] = { };
        int32 PostMMR[2] = { };
    };

    class ClientGetGarrisonInfoResult
    {
        std::vector<int32> ArchivedMissions;
        int32 GarrSiteID = 0;
        int32 FactionIndex = 0;
        std::vector<GarrisonMission> Missions;
        std::vector<GarrisonBuildingInfo> Buildings;
        std::vector<GarrisonFollower> Followers;
        std::vector<GarrisonPlotInfo> Plots;
        int32 GarrSiteLevelID = 0;
    };

    class ClientGarrisonPlotPlaced
    {
        GarrisonPlotInfo PlotInfo;
    };

    class ClientGarrisonPlotRemoved
    {
        int32 GarrPlotInstanceID = 0;
    };

    class ClientGarrisonPlaceBuildingResult
    {
        int32 Result = 0;
        GarrisonBuildingInfo BuildingInfo;
    };

    class ClientGarrisonBuildingRemoved
    {
        int32 GarrPlotInstanceID = 0;
        int32 GarrBuildingID = 0;
    };

    class ClientGarrisonLearnSpecializationResult
    {
        int32 Result = 0;
        int32 GarrSpecID = 0;
    };

    class ClientGarrisonBuildingSetActiveSpecializationResult
    {
        int32 CurrentGarrSpecID = 0;
        int32 Result = 0;
        int32 GarrPlotInstanceID = 0;
    };

    class ClientGarrisonLearnBlueprintResult
    {
        int32 BuildingID = 0;
        int32 Result = 0;
    };

    class ClientGarrisonRequestBlueprintAndSpecializationDataResult
    {
        std::vector<int32> SpecializationsKnown;
        std::vector<int32> BlueprintsKnown;
    };

    class ClientGarrisonRemoteInfo
    {
        CliGarrisonRemoteInfo Info;
    };

    class ClientGarrisonBuildingActivated
    {
        int32 GarrPlotInstanceID = 0;
    };

    class ClientGarrisonUpgradeResult
    {
        int32 GarrSiteLevelID = 0;
        int32 Result = 0;
    };

    class ClientGarrisonAddFollowerResult
    {
        GarrisonFollower Follower;
        int32 Result = 0;
    };

    class ClientGarrisonRemoveFollowerResult
    {
        uint64 FollowerDBID = 0;
        int32 Result = 0;
    };

    class ClientGarrisonListFollowersCheatResult
    {
        std::vector<GarrisonFollower> Followers;
    };

    class ClientGarrisonAddMissionResult
    {
        GarrisonMission Mission;
        int32 Result = 0;
    };

    class ClientGarrisonStartMissionResult
    {
        int32 Result = 0;
        GarrisonMission Mission;
        std::vector<uint64> FollowerDBIDs;
    };

    class ClientGarrisonCompleteMissionResult
    {
        int32 Result = 0;
        GarrisonMission Mission;
        int32 MissionRecID = 0;
    };

    class ClientGarrisonMissionBonusRollResult
    {
        int32 Result = 0;
        bool RollSucceeded = false;
        int32 MissionRecID = 0;
        GarrisonMission Mission;
        int32 BonusIndex = 0;
    };

    class ClientGarrisonFollowerChangedXP
    {
        GarrisonFollower Follower;
    };

    class ClientGarrisonFollowerChangedItemLevel
    {
        GarrisonFollower Follower;
    };

    class ClientGarrisonAssignFollowerToBuildingResult
    {
        uint64 FollowerDBID = 0;
        int32 Result = 0;
        int32 PlotInstanceID = 0;
    };

    class ClientGarrisonRemoveFollowerFromBuildingResult
    {
        uint64 FollowerDBID = 0;
        int32 Result = 0;
    };

    class ClientGarrisonDeleteResult
    {
        int32 Result = 0;
        int32 GarrSiteID = 0;
    };

    class ClientGarrisonOpenArchitect
    {
        ObjectGuid NpcGUID;
    };

    class ClientGarrisonOpenMissionNPC
    {
        ObjectGuid NpcGUID;
    };

    class ClientOpenShipmentNPCFromGossip
    {
        ObjectGuid NpcGUID;
        int32 CharShipmentContainerID = 0;
    };

    class ClientGetShipmentInfoResponse
    {
        std::vector<CliCharacterShipment> Shipments;
        int32 PlotInstanceID = 0;
        int32 ShipmentID = 0;
        bool Success = false;
        int32 MaxShipments = 0;
    };

    class ClientOpenShipmentNPCResult
    {
        int32 CharShipmentContainerID = 0;
        bool Success = false;
    };

    class ClientCreateShipmentResponse
    {
        uint64 ShipmentID = 0;
        int32 Result = 0;
        int32 ShipmentRecID = 0;
    };

    class ClientCompleteShipmentResponse
    {
        uint64 ShipmentID = 0;
        int32 Result = 0;
    };

    class ClientGetShipmentsOfTypeResponse
    {
        int32 ContainerID = 0;
        std::vector<CliCharacterShipment> Shipments;
    };

    class ClientReadItemResultOK
    {
        ObjectGuid Item;
    };

    class ClientReadItemResultFailed
    {
        ObjectGuid Item;
        ReadItemFailure Subcode;
        int32 Delay = 0;
    };

    class ClientScenarioOutOfBounds
    {
        int32 TimeRemaining = 0;
    };

    class ClientShowMailbox
    {
        ObjectGuid PostmasterGUID;
    };

    class ClientCharFactionChangeResult
    {
        uint8 Result = 0;
        ObjectGuid Guid;
        Optional<CharFactionChangeDisplayInfo> Display;
    };

    class ClientRaidDifficultySet
    {
        int32 DifficultyID = 0;
    };

    class ClientXPGainEnabled
    {
        bool Enabled = false;
    };

    class ClientRaidGroupOnly
    {
        uint32 Reason = 0;
        int32 Delay = 0;
    };

    class ClientInstanceEncounterEngageUnit
    {
        ObjectGuid Unit;
        uint8 TargetFramePriority = 0;
    };

    class ClientInstanceEncounterDisengageUnit
    {
        ObjectGuid Unit;
    };

    class ClientInstanceEncounterChangePriority
    {
        ObjectGuid Unit;
        uint8 TargetFramePriority = 0;
    };

    class ClientInstanceEncounterTimerStart
    {
        int32 TimeRemaining = 0;
    };

    class ClientInstanceEncounterObjectiveStart
    {
        int32 ObjectiveID = 0;
    };

    class ClientInstanceEncounterObjectiveComplete
    {
        int32 ObjectiveID = 0;
    };

    class ClientInstanceEncounterStart
    {
        uint32 NextCombatResChargeTime = 0;
        uint32 CombatResChargeRecovery = 0;
        int32 MaxInCombatResCount = 0;
        int32 InCombatResCount = 0;
    };

    class ClientInstanceEncounterObjectiveUpdate
    {
        int32 ProgressAmount = 0;
        int32 ObjectiveID = 0;
    };

    class ClientInstanceEncounterGainCombatResurrectionCharge
    {
        uint32 CombatResChargeRecovery = 0;
        int32 InCombatResCount = 0;
    };

    class ClientTutorialFlags
    {
        uint8 TutorialData[32] = { };
    };

    class ClientCharacterUpgradeStarted
    {
        ObjectGuid CharacterGUID;
    };

    class ClientCharacterUpgradeComplete
    {
        std::vector<int32> Items;
        ObjectGuid CharacterGUID;
    };

    class ClientCharacterUpgradeAborted
    {
        ObjectGuid CharacterGUID;
    };

    class ClientDisplayQuestPopup
    {
        int32 QuestID = 0;
    };

    class ClientUpdateCharacterFlags
    {
        ObjectGuid Character;
        Optional<uint32> Flags3;
        Optional<uint32> Flags;
        Optional<uint32> Flags2;
    };

    class ClientTest128BitGuidsResponse
    {
        int32128 Guid;
    };

    class ClientReplaceTrophyResponse
    {
        bool Success = false;
    };

    class ClientGetTrophyListResponse
    {
        std::vector<int32> TrophyID;
        bool Success = false;
    };

    class CliItemTextCache
    {
        std::string Text;
    };

    class ClientQueryItemTextResponse
    {
        ObjectGuid Id;
        bool Valid = false;
        CliItemTextCache Item;
    };

    class ClientItemCooldown
    {
        ObjectGuid ItemGuid;
        uint32 SpellID = 0;
    };

    class ClientDamageCalcLogEntry
    {
        std::string Op;
        uint32 Var = 0;
        float Value = 0.0f;
        float Damage = 0.0f;
    };

    class ClientDamageCalcLog
    {
        uint32 SourceType = 0;
        ObjectGuid Attacker;
        std::vector<ClientDamageCalcLogEntry> Entries;
        uint32 SpellID = 0;
        ObjectGuid Defender;
    };

    class ClientEmote
    {
        ObjectGuid Guid;
        uint32 EmoteID = 0;
    };

    class ClientTriggerCinematic
    {
        uint32 CinematicID = 0;
    };

    class ClientUpdateObject
    {
        uint32 NumObjUpdates = 0;
        uint16 MapID = 0;
        Data Data;
    };

    class ClientUndeleteCharacterResponse
    {
        ObjectGuid CharacterGuid;
        int32 ClientToken = 0;
        UndeleteCharacterResult Result;
    };

    class ClientUndeleteCooldownStatusResponse
    {
        bool OnCooldown = false;
    };

    class ClientTreasureDebug
    {
        uint32 Depth = 0;
        std::string Text;
    };

    class ClientItemBonusDebug
    {
        std::string Text;
    };

    class ClientChat
    {
        ChatMsg Chat;
    };

    class ClientWho
    {
        WhoResponse Response;
    };

    class ClientMOTDStruct
    {
        std::string Line;
    };

    class ClientMOTD
    {
        std::vector<ClientMOTDStruct> Text;
    };

    class ClientChatPlayerAmbiguous
    {
        std::string Name;
    };

    class ClientSpamRecord
    {
        std::string SpamMessage;
    };

    class ClientExpectedSpamRecords
    {
        std::vector<ClientSpamRecord> SpamRecord;
    };

    class ClientAvailableVoiceChannel
    {
        uint8 SessionType = 0;
        ObjectGuid LocalGUID;
        ObjectGuid SessionGUID;
        std::string ChannelName;
    };

    class ClientVoiceChatStatus
    {
        bool Enabled = false;
    };

    class ClientVoiceParentalControls
    {
        bool EnableMicrophone = false;
        bool EnableVoiceChat = false;
    };

    class ClientVoiceSessionRosterUpdateMember
    {
        ObjectGuid MemberGUID;
        uint8 NetworkId = 0;
        uint8 Priority = 0;
        uint8 Flags = 0;
    };

    class ClientVoiceSessionRosterUpdate
    {
        uint16 ComsatPort = 0;
        ObjectGuid LocalMemberGUID;
        uint16 SessionNetworkID = 0;
        uint8 SessionType = 0;
        uint8 LocalFlags = 0;
        std::string ChannelName;
        uint32 ComsatAddress = 0;
        ObjectGuid ClientGUID;
        uint8 LocalNetworkID = 0;
        std::vector<ClientVoiceSessionRosterUpdateMember> Members;
        uint8 Digest[16] = { };
    };

    class ClientVoiceSessionLeave
    {
        ObjectGuid ClientGUID;
        ObjectGuid SessionGUID;
    };

    class ClientChatNotInParty
    {
        uint32 SlashCmd = 0;
    };

    class ClientChatRestricted
    {
        uint8 Reason = 0;
    };

    class ClientRaidInstanceMessage
    {
        uint8 Type = 0;
        uint32 DifficultyID = 0;
        uint32 MapID = 0;
        bool Locked = false;
        int32 TimeLeft = 0;
        bool Extended = false;
    };

    class ClientZoneUnderAttack
    {
        int32 AreaID = 0;
    };

    class ClientDefenseMessage
    {
        int32 ZoneID = 0;
        std::string MessageText;
    };

    class ClientChatPlayerNotfound
    {
        std::string Name;
    };

    class ClientChatAutoResponded
    {
        bool IsDND = false;
        uint32 RealmAddress = 0;
        std::string AfkMessage;
    };

    class ClientUserlistAdd
    {
        uint8 ChannelFlags = 0;
        uint8 UserFlags = 0;
        std::string ChannelName;
        ObjectGuid AddedUserGUID;
        int32 ChannelID = 0;
    };

    class ClientUserlistRemove
    {
        uint8 ChannelFlags = 0;
        std::string ChannelName;
        int32 ChannelID = 0;
        ObjectGuid RemovedUserGUID;
    };

    class ClientUserlistUpdate
    {
        uint8 ChannelFlags = 0;
        uint8 UserFlags = 0;
        std::string ChannelName;
        ObjectGuid UpdatedUserGUID;
        int32 ChannelID = 0;
    };

    class ClientServerFirstAchievement
    {
        ObjectGuid PlayerGUID;
        std::string Name;
        int32 AchievementID = 0;
        bool GuildAchievement = false;
    };

    class ClientChannelNotify
    {
        std::string Sender;
        ObjectGuid SenderGuid;
        uint8 Type = 0;
        uint8 OldFlags = 0;
        uint8 NewFlags = 0;
        std::string Channel;
        uint32 SenderVirtualRealm = 0;
        ObjectGuid TargetGuid;
        uint32 TargetVirtualRealm = 0;
        int32 ChatChannelID = 0;
    };

    class ClientChannelNotifyJoined
    {
        std::string ChannelWelcomeMsg;
        int32 ChatChannelID = 0;
        int32 InstanceID = 0;
        uint8 ChannelFlags = 0;
        std::string Channel;
    };

    class ClientChannelNotifyLeft
    {
        std::string Channel;
        int32 ChatChannelID = 0;
        bool Suspended = false;
    };

    class ChannelPlayer
    {
        ObjectGuid Guid;
        uint32 VirtualRealmAddress = 0;
        uint8 Flags = 0;
    };

    class ClientChannelList
    {
        std::vector<ChannelPlayer> Members;
        std::string Channel;
        uint8 ChannelFlags = 0;
        bool Display = false;
    };

    class ClientChatServerMessage
    {
        std::string std::stringParam;
        int32 MessageID = 0;
    };

    class ClientConnectionAuthChallenge
    {
        uint32 Challenge = 0;
        uint32 DosChallenge[8] = { };
        uint8 DosZeroBits = 0;
    };

    class ClientConnectionSuspendComms
    {
        uint32 Serial = 0;
    };

    class ClientConnectionConnectTo
    {
        uint64 Key = 0;
        uint32 Serial = 0;
        uint8 Where[256] = { };
        uint8 Con = 0;
    };

    class ClientConnectionPong
    {
        uint32 Serial = 0;
    };

    class ClientAllGuildAchievements
    {
        std::vector<EarnedAchievement> Earned;
    };

    class ClientGuildSendGuildXP
    {
        long GuildXPToLevel;
        long MemberTotalXP;
        long MemberWeeklyXP;
        long GuildTotalXP;
    };

    class ClientGuildSendMaxDailyXP
    {
        long Xp;
    };

    class ClientGuildSendRankChange
    {
        ObjectGuid Other;
        bool Promote = false;
        ObjectGuid Officer;
        uint32 RankID = 0;
    };

    class ClientGuildCommandResult
    {
        std::string Name;
        int32 Result = 0;
        int32 Command = 0;
    };

    class ClientGuildRosterProfessionData
    {
        int32 DbID = 0;
        int32 Rank = 0;
        int32 Step = 0;
    };

    class ClientGuildRosterMemberData
    {
        ObjectGuid Guid;
        long WeeklyXP;
        long TotalXP;
        int32 RankID = 0;
        int32 AreaID = 0;
        int32 PersonalAchievementPoints = 0;
        int32 GuildReputation = 0;
        int32 GuildRepToCap = 0;
        float LastSave = 0.0f;
        std::string Name;
        uint32 VirtualRealmAddress = 0;
        std::string Note;
        std::string OfficerNote;
        uint8 Status = 0;
        uint8 Level = 0;
        uint8 ClassID = 0;
        uint8 Gender = 0;
        bool Authenticated = false;
        bool SorEligible = false;
        ClientGuildRosterProfessionData Profession[2] = { };
    };

    class ClientGuildRoster
    {
        std::vector<ClientGuildRosterMemberData> MemberData;
        int32 GuildFlags = 0;
        std::string WelcomeText;
        std::string InfoText;
        Data CreateDate;
        int32 NumAccounts = 0;
        int32 MaxWeeklyRep = 0;
    };

    class ClientGuildRosterUpdate
    {
        std::vector<ClientGuildRosterMemberData> MemberData;
    };

    class ClientGuildMemberRecipes
    {
        ObjectGuid Member;
        int32 SkillRank = 0;
        int32 SkillLineID = 0;
        int32 SkillStep = 0;
        uint8 SkillLineBitArray[300] = { };
    };

    class GuildKnownRecipes
    {
        int32 SkillLineID = 0;
        uint8 SkillLineBitArray[300] = { };
    };

    class ClientGuildKnownRecipes
    {
        std::vector<GuildKnownRecipes> Recipes;
    };

    class ClientGuildMembersWithRecipe
    {
        int32 SpellID = 0;
        std::vector<ObjectGuid> Members;
        int32 SkillLineID = 0;
    };

    class GuildRewardItem
    {
        uint32 ItemID = 0;
        std::vector<uint32> AchievementsRequired;
        uint32 RaceMask = 0;
        int32 MinGuildLevel = 0;
        int32 MinGuildRep = 0;
        uint64 Cost = 0;
    };

    class ClientGuildRewardList
    {
        std::vector<GuildRewardItem> RewardItems;
        time_t Version = time_t(0);
    };

    class GuildNewsEvent
    {
        int32 Id = 0;
        Data CompletedDate;
        int32 Type = 0;
        int32 Flags = 0;
        ObjectGuid MemberGuid;
        std::vector<ObjectGuid> MemberList;
        int32 Data[2] = { };
    };

    class ClientGuildNews
    {
        std::vector<GuildNewsEvent> News;
    };

    class ClientGuildNewsDeleted
    {
        int32 Id = 0;
    };

    class GuildCriteriaProgress
    {
        int32 CriteriaID = 0;
        time_t DateCreated = time_t(0);
        time_t DateStarted = time_t(0);
        time_t DateUpdated = time_t(0);
        uint64 Quantity = 0;
        ObjectGuid PlayerGUID;
        int32 Flags = 0;
    };

    class ClientGuildCriteriaUpdate
    {
        std::vector<GuildCriteriaProgress> Progress;
    };

    class ClientGuildAchievementEarned
    {
        int32 AchievementID = 0;
        ObjectGuid GuildGUID;
        Data TimeEarned;
    };

    class ClientGuildAchievementDeleted
    {
        ObjectGuid GuildGUID;
        int32 AchievementID = 0;
        Data TimeDeleted;
    };

    class ClientGuildCriteriaDeleted
    {
        ObjectGuid GuildGUID;
        int32 CriteriaID = 0;
    };

    class ClientGuildAchievementMember
    {
        ObjectGuid MemberGUID;
    };

    class ClientGuildAchievementMembers
    {
        ObjectGuid GuildGUID;
        std::vector<ClientGuildAchievementMember> Member;
        int32 AchievementID = 0;
    };

    class CliGuildRankData
    {
        uint32 RankID = 0;
        uint32 RankOrder = 0;
        std::string RankName;
        uint32 Flags = 0;
        uint32 WithdrawGoldLimit = 0;
        uint32 TabFlags[8] = { };
        uint32 TabWithdrawItemLimit[8] = { };
    };

    class ClientGuildRanks
    {
        std::vector<CliGuildRankData> Ranks;
    };

    class ClientGuildXPEarned
    {
        long Xp;
    };

    class ClientGuildMemberUpdateNote
    {
        std::string Note;
        ObjectGuid Member;
        bool IsPublic = false;
    };

    class ClientGuildInvite
    {
        uint32 EmblemColor = 0;
        int32 Level = 0;
        uint32 EmblemStyle = 0;
        ObjectGuid GuildGUID;
        std::string GuildName;
        uint32 OldGuildVirtualRealmAddress = 0;
        std::string OldGuildName;
        uint32 Background = 0;
        ObjectGuid OldGuildGUID;
        uint32 BorderStyle = 0;
        uint32 GuildVirtualRealmAddress = 0;
        std::string InviterName;
        uint32 BorderColor = 0;
        uint32 InviterVirtualRealmAddress = 0;
    };

    class ClientGuildPartyState
    {
        float GuildXPEarnedMult = 0.0f;
        int32 NumMembers = 0;
        bool InGuildParty = false;
        int32 NumRequired = 0;
    };

    class ClientGuildReputationWeeklyCap
    {
        int32 RepToCap = 0;
    };

    class ClientGuildReputationReactionChanged
    {
        ObjectGuid MemberGUID;
    };

    class GuildPostData
    {
        bool Active = false;
        int32 PlayStyle = 0;
        int32 Availability = 0;
        int32 ClassRoles = 0;
        int32 LevelRange = 0;
        time_t SecondsRemaining = time_t(0);
        std::string Comment;
    };

    class ClientLFGuildPost
    {
        Optional<GuildPostData> Post;
    };

    class LFGuildBrowseData
    {
        std::string GuildName;
        ObjectGuid GuildGUID;
        uint32 GuildVirtualRealm = 0;
        int32 GuildLevel = 0;
        int32 GuildMembers = 0;
        int32 GuildAchievementPoints = 0;
        int32 PlayStyle = 0;
        int32 Availability = 0;
        int32 ClassRoles = 0;
        int32 LevelRange = 0;
        int32 EmblemStyle = 0;
        int32 EmblemColor = 0;
        int32 BorderStyle = 0;
        int32 BorderColor = 0;
        int32 Background = 0;
        std::string Comment;
        int8 Cached = 0;
        int8 MembershipRequested = 0;
    };

    class ClientLFGuildBrowse
    {
        std::vector<LFGuildBrowseData> Post;
    };

    class LFGuildRecruitData
    {
        ObjectGuid RecruitGUID;
        std::string Name;
        uint32 RecruitVirtualRealm = 0;
        std::string Comment;
        int32 CharacterClass = 0;
        int32 CharacterGender = 0;
        int32 CharacterLevel = 0;
        int32 ClassRoles = 0;
        int32 PlayStyle = 0;
        int32 Availability = 0;
        uint32 SecondsSinceCreated = 0;
        uint32 SecondsUntilExpiration = 0;
    };

    class ClientLFGuildRecruits
    {
        std::vector<LFGuildRecruitData> Recruits;
        time_t UpdateTime = time_t(0);
    };

    class ClientLFGuildCommandResult
    {
        int32 CommandID = 0;
        int8 Success = 0;
    };

    class LFGuildApplicationData
    {
        ObjectGuid GuildGUID;
        uint32 GuildVirtualRealm = 0;
        std::string GuildName;
        int32 ClassRoles = 0;
        int32 PlayStyle = 0;
        int32 Availability = 0;
        uint32 SecondsSinceCreated = 0;
        uint32 SecondsUntilExpiration = 0;
        std::string Comment;
    };

    class ClientLFGuildApplications
    {
        std::vector<LFGuildApplicationData> Application;
        int32 NumRemaining = 0;
    };

    class ClientGuildChallengeUpdate
    {
        int32 MaxCount[6] = { };
        int32 Xp[6] = { };
        int32 Gold[6] = { };
        int32 CurrentCount[6] = { };
        int32 MaxLevelGold[6] = { };
    };

    class ClientGuildChallengeCompleted
    {
        int32 MaxCount = 0;
        int32 ChallengeType = 0;
        int32 GoldAwarded = 0;
        int32 XpAwarded = 0;
        int32 CurrentCount = 0;
    };

    class ClientGMGuildSaveResponse
    {
        bool Success = false;
        Data ProfileData;
    };

    class ClientGuildReset
    {
        ObjectGuid GuildGUID;
    };

    class ClientGuildMoveStarting
    {
        ObjectGuid GuildGUID;
    };

    class ClientGuildMoved
    {
        std::string TargetRealmName;
        ObjectGuid GuildGUID;
    };

    class ClientGuildNameChanged
    {
        ObjectGuid GuildGUID;
        std::string GuildName;
    };

    class ClientGuildFlaggedForRename
    {
        bool FlagSet = false;
    };

    class ClientGuildChangeNameResult
    {
        bool Success = false;
    };

    class GuildBankTabInfo
    {
        int32 TabIndex = 0;
        std::string Name;
        std::string Icon;
    };

    class GuildBankSocketEnchant
    {
        int32 SocketIndex = 0;
        int32 SocketEnchantID = 0;
    };

    class GuildBankItemInfo
    {
        int32 Slot = 0;
        ItemInstance Item;
        int32 Count = 0;
        int32 EnchantmentID = 0;
        int32 Charges = 0;
        std::vector<GuildBankSocketEnchant> SocketEnchant;
        int32 OnUseEnchantmentID = 0;
        bool Locked = false;
        int32 Flags = 0;
    };

    class ClientGuildBankQueryResults
    {
        std::vector<GuildBankItemInfo> ItemInfo;
        int32 WithdrawalsRemaining = 0;
        int32 Tab = 0;
        std::vector<GuildBankTabInfo> TabInfo;
        bool FullUpdate = false;
        uint64 Money = 0;
    };

    class GuildBankLogEntry
    {
        ObjectGuid PlayerGUID;
        uint32 TimeOffset = 0;
        int8 EntryType = 0;
        Optional<uint64> Money;
        Optional<int32> ItemID;
        Optional<int32> Count;
        Optional<int8> OtherTab;
    };

    class ClientGuildBankLogQueryResults
    {
        Optional<uint64> WeeklyBonusMoney;
        std::vector<GuildBankLogEntry> Entry;
        int32 Tab = 0;
    };

    class ClientGuildBankRemainingWithdrawMoney
    {
        uint64 RemainingWithdrawMoney = 0;
    };

    class GuildRankTabPermissions
    {
        int32 Flags = 0;
        int32 WithdrawItemLimit = 0;
    };

    class ClientGuildPermissionsQueryResults
    {
        int32 NumTabs = 0;
        int32 WithdrawGoldLimit = 0;
        int32 Flags = 0;
        std::vector<GuildRankTabPermissions> Tab;
        uint32 RankID = 0;
    };

    class ClientGuildEventEntry
    {
        ObjectGuid PlayerGUID;
        ObjectGuid OtherGUID;
        uint32 TransactionDate = 0;
        uint8 TransactionType = 0;
        uint8 RankID = 0;
    };

    class ClientGuildEventLogQueryResults
    {
        std::vector<ClientGuildEventEntry> Entry;
    };

    class ClientGuildBankTextQueryResult
    {
        int32 Tab = 0;
        std::string Text;
    };

    class CliGuildInfoRank
    {
        int32 RankID = 0;
        int32 RankOrder = 0;
        std::string RankName;
    };

    class CliGuildInfo
    {
        ObjectGuid GuildGUID;
        uint32 VirtualRealmAddress = 0;
        std::string GuildName;
        std::vector<CliGuildInfoRank> Ranks;
        int32 EmblemStyle = 0;
        int32 EmblemColor = 0;
        int32 BorderStyle = 0;
        int32 BorderColor = 0;
        int32 BackgroundColor = 0;
    };

    class ClientQueryGuildInfoResponse
    {
        ObjectGuid GuildGuid;
        bool Allow = false;
        CliGuildInfo Info;
    };

    class ClientGuildInviteDeclined
    {
        std::string Name;
        bool AutoDecline = false;
        uint32 VirtualRealmAddress = 0;
    };

    class ClientGuildEventPlayerJoined
    {
        ObjectGuid Guid;
        std::string Name;
        uint32 VirtualRealmAddress = 0;
    };

    class ClientGuildEventPlayerLeft
    {
        std::string LeaverName;
        uint32 LeaverVirtualRealmAddress = 0;
        bool Removed = false;
        ObjectGuid LeaverGUID;
        uint32 RemoverVirtualRealmAddress = 0;
        std::string RemoverName;
        ObjectGuid RemoverGUID;
    };

    class ClientGuildEventNewLeader
    {
        uint32 NewLeaderVirtualRealmAddress = 0;
        uint32 OldLeaderVirtualRealmAddress = 0;
        std::string NewLeaderName;
        ObjectGuid NewLeaderGUID;
        bool SelfPromoted = false;
        ObjectGuid OldLeaderGUID;
        std::string OldLeaderName;
    };

    class ClientGuildEventMotd
    {
        std::string MotdText;
    };

    class ClientGuildEventPresenceChange
    {
        bool LoggedOn = false;
        uint32 VirtualRealmAddress = 0;
        std::string Name;
        ObjectGuid Guid;
        bool Mobile = false;
    };

    class ClientGuildEventRankChanged
    {
        int32 RankID = 0;
    };

    class ClientGuildEventTabModified
    {
        std::string Icon;
        int32 Tab = 0;
        std::string Name;
    };

    class ClientGuildEventTabTextChanged
    {
        int32 Tab = 0;
    };

    class ClientGuildEventBankMoneyChanged
    {
        uint64 Money = 0;
    };

    class CollisionHeightInfo
    {
        float Height = 0.0f;
        float Scale = 0.0f;
        UpdateCollisionHeightReason Reason;
    };

    class KnockBackInfo
    {
        float HorzSpeed = 0.0f;
        Vector2 Direction;
        float InitVertSpeed = 0.0f;
    };

    class MoveStateChange
    {
        uint16 MessageID = 0;
        uint32 SequenceIndex = 0;
        Optional<float> Speed;
        Optional<KnockBackInfo> KnockBack;
        Optional<int32> VehicleRecID;
        Optional<CollisionHeightInfo> CollisionHeight;
        Optional<CliMovementForce> MovementForce;
    };

    class ClientOnMonsterMove
    {
        MovementMonsterSpline SplineData;
        ObjectGuid MoverGUID;
        Vector3 Position;
    };

    class ClientMoveSetActiveMover
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveUpdateRunSpeed
    {
        CliMovementStatus Status;
        float Speed = 0.0f;
    };

    class ClientMoveUpdateRunBackSpeed
    {
        float Speed = 0.0f;
        CliMovementStatus Status;
    };

    class ClientMoveUpdateWalkSpeed
    {
        CliMovementStatus Status;
        float Speed = 0.0f;
    };

    class ClientMoveUpdateSwimSpeed
    {
        CliMovementStatus Status;
        float Speed = 0.0f;
    };

    class ClientMoveUpdateSwimBackSpeed
    {
        CliMovementStatus Status;
        float Speed = 0.0f;
    };

    class ClientMoveUpdateFlightSpeed
    {
        CliMovementStatus Status;
        float Speed = 0.0f;
    };

    class ClientMoveUpdateFlightBackSpeed
    {
        float Speed = 0.0f;
        CliMovementStatus Status;
    };

    class ClientMoveUpdateTurnRate
    {
        float Speed = 0.0f;
        CliMovementStatus Status;
    };

    class ClientMoveUpdatePitchRate
    {
        float Speed = 0.0f;
        CliMovementStatus Status;
    };

    class ClientMoveUpdateCollisionHeight
    {
        float Scale = 0.0f;
        CliMovementStatus Status;
        float Height = 0.0f;
    };

    class ClientMoveUpdate
    {
        CliMovementStatus Status;
    };

    class ClientMoveUpdateTeleport
    {
        CliMovementStatus Status;
        std::vector<CliMovementForce> MovementForces;
        Optional<float> SwimBackSpeed;
        Optional<float> FlightSpeed;
        Optional<float> SwimSpeed;
        Optional<float> WalkSpeed;
        Optional<float> TurnRate;
        Optional<float> RunSpeed;
        Optional<float> FlightBackSpeed;
        Optional<float> RunBackSpeed;
        Optional<float> PitchRate;
    };

    class ClientMoveUpdateKnockBack
    {
        CliMovementStatus Status;
    };

    class ClientMoveUpdateApplyMovementForce
    {
        CliMovementStatus Status;
        CliMovementForce Force;
    };

    class ClientMoveUpdateRemoveMovementForce
    {
        uint32 MovementForceID = 0;
        CliMovementStatus Status;
    };

    class ClientMoveSplineSetRunSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetRunBackSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetSwimSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetSwimBackSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetFlightSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetFlightBackSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetWalkBackSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetTurnRate
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSplineSetPitchRate
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
    };

    class ClientMoveSetRunSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetRunBackSpeed
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveSetSwimSpeed
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveSetSwimBackSpeed
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveSetFlightSpeed
    {
        ObjectGuid MoverGUID;
        float Speed = 0.0f;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetFlightBackSpeed
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveSetWalkSpeed
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveSetTurnRate
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveSetPitchRate
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        float Speed = 0.0f;
    };

    class ClientMoveRoot
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveUnroot
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetWaterWalk
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetLandWalk
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetFeatherFall
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetNormalFall
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetHovering
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveUnsetHovering
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveKnockBack
    {
        ObjectGuid MoverGUID;
        Vector2 Direction;
        float HorzSpeed = 0.0f;
        uint32 SequenceIndex = 0;
        float VertSpeed = 0.0f;
    };

    class VehicleTeleport
    {
        uint8 VehicleSeatIndex = 0;
        bool VehicleExitVoluntary = false;
        bool VehicleExitTeleport = false;
    };

    class ClientMoveTeleport
    {
        Vector3 Position;
        Optional<VehicleTeleport> Vehicle;
        uint32 SequenceIndex = 0;
        ObjectGuid MoverGUID;
        Optional<ObjectGuid> TransportGUID;
        float Facing = 0.0f;
    };

    class ClientMoveSetCanFly
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveUnsetCanFly
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetCanTurnWhileFalling
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveUnsetCanTurnWhileFalling
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetIgnoreMovementForces
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveUnsetIgnoreMovementForces
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveEnableTransitionBetweenSwimAndFly
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveDisableTransitionBetweenSwimAndFly
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveDisableGravity
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveEnableGravity
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveDisableCollision
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveEnableCollision
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveSetCollisionHeight
    {
        float Scale = 0.0f;
        ObjectGuid MoverGUID;
        uint32 MountDisplayID = 0;
        UpdateCollisionHeightReason Reason;
        uint32 SequenceIndex = 0;
        float Height = 0.0f;
    };

    class ClientMoveSetVehicleRecID
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        int32 VehicleRecID = 0;
    };

    class ClientMoveApplyMovementForce
    {
        CliMovementForce Force;
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
    };

    class ClientMoveRemoveMovementForce
    {
        ObjectGuid MoverGUID;
        uint32 SequenceIndex = 0;
        uint32 MovementForceID = 0;
    };

    class ClientMoveSetCompoundState
    {
        ObjectGuid MoverGUID;
        std::vector<MoveStateChange> StateChanges;
    };

    class ClientMoveSkipTime
    {
        ObjectGuid MoverGUID;
        uint32 TimeSkipped = 0;
    };

    class ClientMoveSplineRoot
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineUnroot
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineDisableGravity
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineEnableGravity
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineDisableCollision
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineEnableCollision
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetFeatherFall
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetNormalFall
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetHover
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineUnsetHover
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetWaterWalk
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetLandWalk
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineStartSwim
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineStopSwim
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetRunMode
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetWalkMode
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineSetFlying
    {
        ObjectGuid MoverGUID;
    };

    class ClientMoveSplineUnsetFlying
    {
        ObjectGuid MoverGUID;
    };

    class ClientFlightSplineSync
    {
        ObjectGuid Guid;
        float SplineDist = 0.0f;
    };

    class ClientDailyQuestsReset
    {
        int32 Count = 0;
    };

    class ClientSetQuestCompletedBit
    {
        int32 Bit = 0;
        int32 QuestID = 0;
    };

    class ClientClearQuestCompletedBit
    {
        int32 QuestID = 0;
        int32 Bit = 0;
    };

    class ClientClearQuestCompletedBits
    {
        std::vector<int32> Qbits;
    };

    class QuestCompletionNPC
    {
        int32 QuestID = 0;
        std::vector<int32> Npc;
    };

    class ClientQuestCompletionNPCResponse
    {
        std::vector<QuestCompletionNPC> QuestCompletionNPCs;
    };

    class ClientQuestGiverQuestComplete
    {
        bool UseQuestReward = false;
        int32 SkillLineIDReward = 0;
        int32 MoneyReward = 0;
        int32 NumSkillUpsReward = 0;
        int32 XpReward = 0;
        int32 QuestId = 0;
        int32 TalentReward = 0;
        bool LaunchGossip = false;
    };

    class ClientIsQuestCompleteResponse
    {
        int32 QuestID = 0;
        bool Complete = false;
    };

    class ClientQuestGiverInvalidQuest
    {
        int32 Reason = 0;
        std::string ReasonText;
    };

    class ClientQuestGiverQuestFailed
    {
        int32 QuestID = 0;
        int32 Reason = 0;
    };

    class ClientQuestUpdateComplete
    {
        int32 QuestID = 0;
    };

    class ClientQuestUpdateFailed
    {
        int32 QuestID = 0;
    };

    class ClientQuestUpdateFailedTimer
    {
        int32 QuestID = 0;
    };

    class ClientQuestUpdateAddCredit
    {
        ObjectGuid VictimGUID;
        int32 ObjectID = 0;
        int32 QuestID = 0;
        uint16 Count = 0;
        uint16 Required = 0;
        uint8 ObjectiveType = 0;
    };

    class ClientQuestUpdateAddCreditSimple
    {
        int32 QuestID = 0;
        int32 ObjectID = 0;
        uint8 ObjectiveType = 0;
    };

    class ClientQuestUpdateAddPvPCredit
    {
        int32 QuestID = 0;
        uint16 Count = 0;
    };

    class ClientQuestConfirmAccept
    {
        std::string QuestTitle;
        ObjectGuid InitiatedBy;
        int32 QuestID = 0;
    };

    class ClientQuestPushResult
    {
        ObjectGuid SenderGUID;
        uint8 Result = 0;
    };

    class QuestGiverStatus
    {
        ObjectGuid Guid;
        uint32 Status = 0;
    };

    class ClientQuestGiverStatusMultiple
    {
        std::vector<QuestGiverStatus> QuestGiver;
    };

    class CliQuestInfoObjectiveSimple
    {
        int32 Id = 0;
        int32 ObjectID = 0;
        int32 Amount = 0;
        uint8 Type = 0;
    };

    class CliQuestInfoObjective
    {
        int32 Id = 0;
        uint8 Type = 0;
        int8 StorageIndex = 0;
        int32 ObjectID = 0;
        int32 Amount = 0;
        int32 Flags = 0;
        std::string Description;
        std::vector<int32> VisualEffects;
    };

    class ClientQuestGiverQuestDetails
    {
        std::string PortraitTurnInName;
        bool DisplayPopup = false;
        std::string PortraitGiverName;
        std::vector<CliQuestInfoObjectiveSimple> Objectives;
        std::string PortraitGiverText;
        bool StartCheat = false;
        QuestRewards QuestRewards;
        ObjectGuid QuestGiverGUID;
        int32 QuestID = 0;
        std::string QuestTitle;
        bool AutoLaunched = false;
        std::vector<QuestDescEmote> DescEmotes;
        int32 QuestPackageID = 0;
        int32 PortraitGiver = 0;
        std::string DescriptionText;
        ObjectGuid InformUnit;
        int32 SuggestedPartyMembers = 0;
        int32 PortraitTurnIn = 0;
        std::vector<int32> LearnSpells;
        std::string PortraitTurninText;
        std::string LogDescription;
        int32 QuestFlags[2] = { };
    };

    class ClientQuestGiverRequestItems
    {
        std::string QuestTitle;
        QuestGiverRequestItems QuestData;
        std::string CompletionText;
    };

    class ClientQuestGiverOfferRewardMessage
    {
        int32 PortraitTurnIn = 0;
        int32 PortraitGiver = 0;
        std::string PortraitGiverText;
        std::string QuestTitle;
        std::string PortraitTurninText;
        std::string PortraitGiverName;
        std::string RewardText;
        std::string PortraitTurnInName;
        QuestGiverOfferReward QuestData;
        int32 QuestPackageID = 0;
    };

    class CliQuestInfoChoiceItem
    {
        int32 ItemID = 0;
        int32 Quantity = 0;
        int32 DisplayID = 0;
    };

    class CliQuestInfo
    {
        int32 QuestId = 0;
        int32 QuestType = 0;
        int32 QuestLevel = 0;
        int32 QuestPackageID = 0;
        int32 QuestMinLevel = 0;
        int32 QuestSortID = 0;
        int32 QuestInfoID = 0;
        int32 SuggestedGroupNum = 0;
        int32 RewardNextQuest = 0;
        int32 RewardXPDifficulty = 0;
        int32 RewardMoney = 0;
        int32 RewardMoneyDifficulty = 0;
        int32 RewardBonusMoney = 0;
        int32 RewardDisplaySpell = 0;
        int32 RewardSpell = 0;
        int32 RewardHonor = 0;
        float RewardKillHonor = 0.0f;
        int32 StartItem = 0;
        int32 Flags = 0;
        int32 FlagsEx = 0;
        int32 POIContinent = 0;
        float POIx = 0.0f;
        float POIy = 0.0f;
        int32 POIPriority = 0;
        std::string LogTitle;
        std::string LogDescription;
        std::string QuestDescription;
        std::string AreaDescription;
        int32 RewardTitle = 0;
        int32 RewardTalents = 0;
        int32 RewardArenaPoints = 0;
        int32 RewardSkillLineID = 0;
        int32 RewardNumSkillUps = 0;
        int32 PortraitGiver = 0;
        int32 PortraitTurnIn = 0;
        std::string PortraitGiverText;
        std::string PortraitGiverName;
        std::string PortraitTurnintext;
        std::string PortraitTurnInName;
        std::string QuestCompletionLog;
        int32 RewardFactionFlags = 0;
        int32 AcceptedSoundKitID = 0;
        int32 CompleteSoundKitID = 0;
        int32 AreaGroupID = 0;
        int32 TimeAllowed = 0;
        std::vector<CliQuestInfoObjective> Objectives;
        int32 RewardItems[4] = { };
        int32 RewardAmount[4] = { };
        int32 ItemDrop[4] = { };
        int32 ItemDropQuantity[4] = { };
        CliQuestInfoChoiceItem UnfilteredChoiceItems[6] = { };
        int32 RewardFactionID[5] = { };
        int32 RewardFactionValue[5] = { };
        int32 RewardFactionOverride[5] = { };
        int32 RewardCurrencyID[4] = { };
        int32 RewardCurrencyQty[4] = { };
    };

    class ClientQueryQuestInfoResponse
    {
        bool Allow = false;
        CliQuestInfo Info;
        uint32 QuestID = 0;
    };

    class ClientGossipText
    {
        int32 QuestID = 0;
        int32 QuestType = 0;
        int32 QuestLevel = 0;
        bool Repeatable = false;
        std::string QuestTitle;
        int32 QuestFlags[2] = { };
    };

    class ClientGossipMessage
    {
        std::vector<ClientGossipOptions> GossipOptions;
        int32 FriendshipFactionID = 0;
        ObjectGuid GossipGUID;
        std::vector<ClientGossipText> GossipQuestText;
        int32 TextID = 0;
        int32 GossipID = 0;
    };

    class ClientQuestGiverQuestListMessage
    {
        int32 GreetEmoteDelay = 0;
        int32 GreetEmoteType = 0;
        ObjectGuid QuestGiverGUID;
        std::vector<ClientGossipText> QuestDataText;
        std::string Greeting;
    };

    class ClientQuestGiverStatus
    {
        ObjectGuid QuestGiverGUID;
        uint32 StatusFlags = 0;
    };

    class ClientQuestForceRemoved
    {
        int32 QuestID = 0;
    };

    class ClientQuestPOIQueryResponse
    {
        std::vector<QuestPOIData> QuestPOIData;
        int32 NumPOIs = 0;
    };

    class ClientSpellChanceProcLog
    {
        ObjectGuid Guid;
        ObjectGuid TargetGUID;
        int32 ProcType = 0;
        float Roll = 0.0f;
        float Needed = 0.0f;
        int32 SpellID = 0;
        int32 ProcSubType = 0;
    };

    class ClientSpellProcScriptLog
    {
        ObjectGuid Caster;
        int32 SpellID = 0;
        int8 Result = 0;
    };

    class ClientCheatIgnoreDimishingReturns
    {
        bool Enabled = false;
    };

    class ClientMirrorImageCreatureData
    {
        ObjectGuid UnitGUID;
        int32 DisplayID = 0;
    };

    class ClientMirrorImageComponentedData
    {
        uint8 FaceVariation = 0;
        std::vector<int32> ItemDisplayID;
        uint8 SkinColor = 0;
        uint8 Gender = 0;
        uint8 HairColor = 0;
        uint8 ClassID = 0;
        ObjectGuid UnitGUID;
        uint8 RaceID = 0;
        ObjectGuid GuildGUID;
        uint8 HairVariation = 0;
        uint8 BeardVariation = 0;
        int32 DisplayID = 0;
    };

    class ClientSpellCooldownStruct
    {
        uint32 SrecID = 0;
        uint32 ForcedCooldown = 0;
    };

    class ClientSpellCooldown
    {
        std::vector<ClientSpellCooldownStruct> SpellCooldowns;
        ObjectGuid Caster;
        uint8 Flags = 0;
    };

    class CategoryCooldown
    {
        int32 Category = 0;
        int32 ModCooldown = 0;
    };

    class ClientCategoryCooldown
    {
        std::vector<CategoryCooldown> CategoryCooldowns;
    };

    class WeeklySpellUse
    {
        int32 Category = 0;
        uint8 Uses = 0;
    };

    class ClientWeeklySpellUsage
    {
        std::vector<WeeklySpellUse> Usage;
    };

    class ClientUpdateWeeklySpellUsage
    {
        WeeklySpellUse Usage;
    };

    class ClientSpellDispellData
    {
        int32 SpellID = 0;
        bool Harmful = false;
        Optional<int32> Rolled;
        Optional<int32> Needed;
    };

    class ClientSpellDispellLog
    {
        std::vector<ClientSpellDispellData> DispellData;
        bool IsBreak = false;
        ObjectGuid TargetGUID;
        bool IsSteal = false;
        int32 DispelledBySpellID = 0;
        ObjectGuid CasterGUID;
    };

    class ClientSpellPeriodicAuraLog
    {
        ObjectGuid TargetGUID;
        std::vector<PeriodicAuraLogEffect> Entries;
        Optional<SpellCastLogData> LogData;
        ObjectGuid CasterGUID;
        int32 SpellID = 0;
    };

    class ClientSpellEnergizeLog
    {
        int32 SpellID = 0;
        ObjectGuid TargetGUID;
        ObjectGuid CasterGUID;
        Optional<SpellCastLogData> LogData;
        int32 Amount = 0;
        int32 Type = 0;
    };

    class ClientSpellHealLog
    {
        Optional<float> CritRollMade;
        int32 SpellID = 0;
        Optional<SpellCastLogData> LogData;
        int32 OverHeal = 0;
        Optional<float> CritRollNeeded;
        bool Crit = false;
        bool Multistrike = false;
        int32 Absorbed = 0;
        ObjectGuid CasterGUID;
        int32 Health = 0;
        ObjectGuid TargetGUID;
    };

    class ClientSpellInterruptLog
    {
        ObjectGuid Victim;
        ObjectGuid Caster;
        int32 SpellID = 0;
        int32 InterruptedSpellID = 0;
    };

    class ClientEnvironmentalDamageLog
    {
        Optional<SpellCastLogData> LogData;
        int32 Absorbed = 0;
        ObjectGuid Victim;
        uint8 Type = 0;
        int32 Resisted = 0;
        int32 Amount = 0;
    };

    class ClientAuraDataInfo
    {
        int32 SpellID = 0;
        uint8 Flags = 0;
        uint32 ActiveFlags = 0;
        uint16 CastLevel = 0;
        uint8 Applications = 0;
        Optional<ObjectGuid> CastUnit;
        Optional<int32> Duration;
        Optional<int32> Remaining;
        std::vector<float> Points;
        std::vector<float> EstimatedPoints;
    };

    class ClientAuraInfo
    {
        uint8 Slot = 0;
        Optional<ClientAuraDataInfo> AuraData;
    };

    class ClientAuraUpdate
    {
        bool UpdateAll = false;
        ObjectGuid UnitGUID;
        std::vector<ClientAuraInfo> Auras;
    };

    class ClientAuraPointsDepleted
    {
        ObjectGuid Unit;
        uint8 Slot = 0;
        uint8 EffectIndex = 0;
    };

    class ClientPetSpellsMessage
    {
        ClientPetSpells Spells;
    };

    class ClientClearCooldowns
    {
        std::vector<int32> SpellID;
        ObjectGuid Guid;
    };

    class ClientIncreaseCastTimeForSpell
    {
        ObjectGuid Caster;
        uint32 CastTime = 0;
        int32 SpellID = 0;
    };

    class ClientClearAllSpellCharges
    {
        ObjectGuid Unit;
    };

    class ClientClearSpellCharges
    {
        ObjectGuid Unit;
        int32 Category = 0;
    };

    class ClientSetSpellCharges
    {
        bool IsPet = false;
        float Count = 0.0f;
        int32 Category = 0;
    };

    class ClientSendKnownSpells
    {
        bool InitialLogin = false;
        std::vector<uint32> KnownSpells;
    };

    class SpellHistoryEntry
    {
        uint32 SpellID = 0;
        uint32 ItemID = 0;
        uint32 Category = 0;
        int32 RecoveryTime = 0;
        int32 CategoryRecoveryTime = 0;
        bool OnHold = false;
    };

    class ClientSendSpellHistory
    {
        std::vector<SpellHistoryEntry> Entries;
    };

    class ClientRefreshSpellHistory
    {
        std::vector<SpellHistoryEntry> Entries;
    };

    class SpellChargeEntry
    {
        uint32 Category = 0;
        uint32 NextRecoveryTime = 0;
        uint8 ConsumedCharges = 0;
    };

    class ClientSendSpellCharges
    {
        std::vector<SpellChargeEntry> Entries;
    };

    class ClientSendUnlearnSpells
    {
        std::vector<uint32> Spells;
    };

    class ClientSpellOrDamageImmune
    {
        ObjectGuid VictimGUID;
        bool IsPeriodic = false;
        uint32 SpellID = 0;
        ObjectGuid CasterGUID;
    };

    class ClientDispelFailed
    {
        std::vector<int32> FailedSpells;
        uint32 SpellID = 0;
        ObjectGuid VictimGUID;
        ObjectGuid CasterGUID;
    };

    class ClientSpellDamageShield
    {
        int32 SpellID = 0;
        ObjectGuid Defender;
        Optional<SpellCastLogData> LogData;
        int32 OverKill = 0;
        int32 TotalDamage = 0;
        ObjectGuid Attacker;
        int32 LogAbsorbed = 0;
        int32 SchoolMask = 0;
    };

    class ClientSpellNonMeleeDamageLogDebugInfo
    {
        float CritRoll = 0.0f;
        float CritNeeded = 0.0f;
        float HitRoll = 0.0f;
        float HitNeeded = 0.0f;
        float MissChance = 0.0f;
        float DodgeChance = 0.0f;
        float ParryChance = 0.0f;
        float BlockChance = 0.0f;
        float GlanceChance = 0.0f;
        float CrushChance = 0.0f;
    };

    class ClientSpellNonMeleeDamageLog
    {
        int32 Absorbed = 0;
        int32 ShieldBlock = 0;
        ObjectGuid Me;
        int32 SpellID = 0;
        int32 Resisted = 0;
        bool Periodic = false;
        uint8 SchoolMask = 0;
        ObjectGuid CasterGUID;
        Optional<SpellCastLogData> LogData;
        int32 Damage = 0;
        Optional<ClientSpellNonMeleeDamageLogDebugInfo> DebugInfo;
        int32 Flags = 0;
        int32 OverKill = 0;
    };

    class ClientSpellInstakillLog
    {
        ObjectGuid Target;
        ObjectGuid Caster;
        int32 SpellID = 0;
    };

    class ClientSpellUpdateChainTargets
    {
        ObjectGuid Guid;
        std::vector<ObjectGuid> Targets;
        int32 SpellID = 0;
    };

    class SpellChannelStartInterruptImmunities
    {
        int32 SchoolImmunities = 0;
        int32 Immunities = 0;
    };

    class SpellTargetedHealPrediction
    {
        ObjectGuid TargetGUID;
        SpellHealPrediction Predict;
    };

    class ClientSpellChannelStart
    {
        int32 SpellID = 0;
        Optional<SpellChannelStartInterruptImmunities> InterruptImmunities;
        ObjectGuid CasterGUID;
        Optional<SpellTargetedHealPrediction> HealPrediction;
        uint32 ChannelDuration = 0;
    };

    class ClientSpellChannelUpdate
    {
        ObjectGuid CasterGUID;
        int32 TimeRemaining = 0;
    };

    class ClientSpellModifierData
    {
        float ModifierValue = 0.0f;
        uint8 ClassIndex = 0;
    };

    class ClientSpellModifier
    {
        uint8 ModIndex = 0;
        std::vector<ClientSpellModifierData> ModifierData;
    };

    class ClientSetFlatSpellModifier
    {
        std::vector<ClientSpellModifier> Modifiers;
    };

    class ClientSetPctSpellModifier
    {
        std::vector<ClientSpellModifier> Modifiers;
    };

    class ClientSpellGo
    {
        Optional<SpellCastLogData> LogData;
        SpellCastData Cast;
    };

    class ClientSpellStart
    {
        SpellCastData Cast;
    };

    class ClientAuraCastLog
    {
        ObjectGuid Victim;
        ObjectGuid Attacker;
        float ApplyRoll = 0.0f;
        int32 SpellID = 0;
        float ApplyRollNeeded = 0.0f;
    };

    class ClientResistLog
    {
        ObjectGuid Attacker;
        ObjectGuid Victim;
        float ResistRoll = 0.0f;
        int32 CastLevel = 0;
        int32 SpellID = 0;
        float ResistRollNeeded = 0.0f;
        uint8 ResistLogFlags = 0;
    };

    class ClientResumeCastBar
    {
        int32 SpellID = 0;
        ObjectGuid Guid;
        ObjectGuid Target;
        uint32 TimeRemaining = 0;
        bool HasInterruptImmunities = false;
        int32 SchoolImmunities = 0;
        int32 Immunities = 0;
        uint32 TotalTime = 0;
    };

    class ClientSpellDelayed
    {
        ObjectGuid Caster;
        int32 ActualDelay = 0;
    };

    class ClientSpellLogEffectGenericVictimParams
    {
        ObjectGuid Victim;
    };

    class ClientSpellLogEffectFeedPetParams
    {
        int32 ItemID = 0;
    };

    class ClientSpellLogEffectTradeSkillItemParams
    {
        int32 ItemID = 0;
    };

    class ClientSpellLogEffectExtraAttacksParams
    {
        ObjectGuid Victim;
        uint32 NumAttacks = 0;
    };

    class ClientSpellLogEffectPowerDrainParams
    {
        ObjectGuid Victim;
        uint32 Points = 0;
        uint32 PowerType = 0;
        float Amplitude = 0.0f;
    };

    class ClientSpellLogEffectDurabilityDamageParams
    {
        ObjectGuid Victim;
        int32 ItemID = 0;
        int32 Amount = 0;
    };

    class ClientSpellLogEffect
    {
        int32 Effect = 0;
        std::vector<ClientSpellLogEffectPowerDrainParams> PowerDrainTargets;
        std::vector<ClientSpellLogEffectExtraAttacksParams> ExtraAttacksTargets;
        std::vector<ClientSpellLogEffectDurabilityDamageParams> DurabilityDamageTargets;
        std::vector<ClientSpellLogEffectGenericVictimParams> GenericVictimTargets;
        std::vector<ClientSpellLogEffectTradeSkillItemParams> TradeSkillTargets;
        std::vector<ClientSpellLogEffectFeedPetParams> FeedPetTargets;
    };

    class ClientSpellExecuteLog
    {
        int32 SpellID = 0;
        ObjectGuid Caster;
        std::vector<ClientSpellLogEffect> Effects;
        Optional<SpellCastLogData> LogData;
    };

    class ClientSpellLogMissDebug
    {
        float HitRoll = 0.0f;
        float HitRollNeeded = 0.0f;
    };

    class ClientSpellLogMissEntry
    {
        ObjectGuid Victim;
        uint8 MissReason = 0;
        Optional<ClientSpellLogMissDebug> Debug;
    };

    class ClientSpellMissLog
    {
        std::vector<ClientSpellLogMissEntry> Entries;
        int32 SpellID = 0;
        ObjectGuid Caster;
    };

    class ClientSpellProcsPerMinuteLog
    {
        SpellProcsPerMinuteLogData LogData;
        ObjectGuid Guid;
        ObjectGuid TargetGUID;
    };

    class ClientSpellMultistrikeEffect
    {
        ObjectGuid Target;
        ObjectGuid Caster;
        int32 SpellID = 0;
        int16 ProcCount = 0;
        int16 ProcNum = 0;
    };

    class GlobalGuildSetLevelCheat
    {
        ObjectGuid GuildGUID;
        int32 Level = 0;
    };

    class GlobalGuildNewsCreateCheat
    {
        ObjectGuid Guild;
        uint32 DateOffset = 0;
        uint32 Data = 0;
        uint32 NewsType = 0;
    };

    class GlobalGuildAddXPCheat
    {
        ObjectGuid Guild;
        int32 Xp = 0;
    };

    class GlobalGuildRequestGuildXP
    {
        ObjectGuid GuildGUID;
    };

    class GlobalGuildSetMaxDailyXP
    {
        int32 MaxGuildDailyXP = 0;
    };

    class GlobalGuildPromoteMember
    {
        ObjectGuid Promotee;
    };

    class GlobalGuildDemoteMember
    {
        ObjectGuid Demotee;
    };

    class GlobalGuildAssignMemberRank
    {
        ObjectGuid Member;
        int32 RankOrder = 0;
    };

    class GlobalGuildOfficerRemoveMember
    {
        ObjectGuid Removee;
    };

    class GlobalGuildAddRank
    {
        std::string Name;
        int32 RankOrder = 0;
    };

    class GlobalGuildDeleteRank
    {
        int32 RankOrder = 0;
    };

    class GlobalGuildShiftRank
    {
        bool ShiftUp = false;
        int32 RankOrder = 0;
    };

    class GlobalGuildSetRankPermissions
    {
        uint32 OldFlags = 0;
        int32 RankID = 0;
        int32 RankOrder = 0;
        std::string RankName;
        uint32 Flags = 0;
        uint32 WithdrawGoldLimit = 0;
        uint32 TabFlags[8] = { };
        uint32 TabWithdrawItemLimit[8] = { };
    };

    class GlobalGuildQueryMemberRecipes
    {
        ObjectGuid GuildMember;
        ObjectGuid GuildGUID;
        int32 SkillLineID = 0;
    };

    class GlobalGuildQueryRecipes
    {
        ObjectGuid GuildGUID;
    };

    class GlobalGuildQueryMembersForRecipe
    {
        ObjectGuid GuildGUID;
        int32 UniqueBit = 0;
        int32 SkillLineID = 0;
        int32 SpellID = 0;
    };

    class GlobalGuildQueryNews
    {
        ObjectGuid GuildGUID;
    };

    class GlobalGuildGetRanks
    {
        ObjectGuid GuildGUID;
    };

    class GlobalGuildNewsUpdateSticky
    {
        int32 NewsID = 0;
        ObjectGuid GuildGUID;
        bool Sticky = false;
    };

    class GlobalGuildSetAchievementTracking
    {
        std::vector<int32> AchievementIDs;
    };

    class GlobalGuildSetFocusedAchievement
    {
        int32 AchievementID = 0;
    };

    class GlobalGuildGetAchievementMembers
    {
        ObjectGuid GuildGUID;
        ObjectGuid PlayerGUID;
        int32 AchievementID = 0;
    };

    class GuildMemberSetNoteData
    {
        ObjectGuid NoteeGUID;
        std::string Note;
        bool IsPublic = false;
    };

    class GlobalGuildSetMemberNote
    {
        GuildMemberSetNoteData Data;
    };

    class GlobalGuildGetRoster
    {
        ObjectGuid PlayerGUID;
        ObjectGuid GuildGUID;
    };

    class GlobalGuildUpdateMotdText
    {
        std::string MotdText;
    };

    class GlobalGuildUpdateInfoText
    {
        std::string InfoText;
    };

    class GlobalLFGuildGetRecruits
    {
        time_t LastUpdate = time_t(0);
    };

    class GlobalLFGuildDeclineRecruit
    {
        ObjectGuid RecruitGUID;
    };

    class GlobalLFGuildRemoveRecruit
    {
        ObjectGuid GuildGUID;
    };

    class GlobalGMSetLFGuildPostComment
    {
        ObjectGuid GuildGUID;
        std::string Comment;
    };

    class GlobalGMSetLFGuildRecruitComment
    {
        ObjectGuid PlayerGUID;
        std::string Comment;
        ObjectGuid GuildGUID;
    };

    class GlobalGuildChangeNameRequest
    {
        std::string NewName;
    };

    class GlobalGuildFlagForRenameCheat
    {
        bool SetFlag = false;
    };

    class GlobalGuildSetReplaceGMSeconds
    {
        int32 Seconds = 0;
    };

    class GlobalGuildBankLogQuery
    {
        int32 Tab = 0;
    };

    class GlobalGuildBankSetTabText
    {
        int32 Tab = 0;
        std::string TabText;
    };

    class GlobalGuildBankTextQuery
    {
        int32 Tab = 0;
    };

    class GlobalGuildBankLockByGM
    {
        std::string GuildName;
    };

    class GlobalGuildBankUnlockByGM
    {
        std::string GuildName;
    };

    class GlobalGuildMemberSendSoRRequest
    {
        ObjectGuid Member;
        std::string Text;
    };

    class GlobalGuildAddBattlenetFriend
    {
        uint32 RoleID = 0;
        uint64 ClientToken = 0;
        bool VerifyOnly = false;
        ObjectGuid TargetGUID;
        std::string InvitationMsg;
    };

    class GlobalChallengeModeRequestLeaders
    {
        time_t LastGuildUpdate = time_t(0);
        int32 MapID = 0;
        time_t LastRealmUpdate = time_t(0);
    };

    class GlobalChallengeModeRequestLeadersCheat
    {
        int32 MapID = 0;
    };

    class GlobalBlackMarketEndAuctionsCheat
    {
        int32 MarketID = 0;
    };

    class GlobalBlackMarketDeleteAuctionCheat
    {
        int32 MarketID = 0;
    };

    class GlobalChallengeModeDumpLeaders
    {
        int32 MapID = 0;
    };

    class GlobalChallengeModeDeleteLeader
    {
        int32 MapID = 0;
        uint32 AttemptID = 0;
    };

    class PlayerCliInitiateTrade
    {
        ObjectGuid Guid;
    };

    class PlayerCliAcceptTrade
    {
        uint32 StateIndex = 0;
    };

    class PlayerCliSetTradeItem
    {
        uint8 TradeSlot = 0;
        uint8 ItemSlotInPack = 0;
        uint8 PackSlot = 0;
    };

    class PlayerClearTradeItem
    {
        uint8 TradeSlot = 0;
    };

    class PlayerCliSetTradeGold
    {
        uint64 Coinage = 0;
    };

    class PlayerCliSetTradeCurrency
    {
        uint32 Type = 0;
        uint32 Quantity = 0;
    };

    class PlayerCreateGuildPetitionCheat
    {
        std::string GuildName;
    };

    class PlayerCliStartProjectCheat
    {
        uint32 ProjectID = 0;
    };

    class PlayerCliEnableResearchSiteCheat
    {
        uint32 FieldID = 0;
        uint32 SiteID = 0;
    };

    class PlayerCliSpawnAllResearchLocsCheat
    {
        uint32 FieldID = 0;
    };

    class PlayerCliRandomizeSurveyHintCheat
    {
        uint8 Randomize = 0;
    };

    class PlayerCliSetPetSlot
    {
        ObjectGuid StableMaster;
        uint32 PetNumber = 0;
        uint8 DestSlot = 0;
    };

    class PlayerCliSetCurrencyFlags
    {
        uint32 Flags = 0;
        uint32 CurrencyID = 0;
    };

    class PlayerCliEndBattlegroundCheat
    {
        int32 Winner = 0;
    };

    class PlayerCliMapControllerSetPointsCheat
    {
        int32 Points = 0;
        uint8 Team = 0;
    };

    class PlayerCliMapControllerAddPointsCheat
    {
        int32 Points = 0;
        uint8 Team = 0;
    };

    class PlayerCliMapControllerSetGameTimeCheat
    {
        int32 Seconds = 0;
    };

    class PlayerCliBFMgrQueueRequest
    {
        uint64 QueueID = 0;
    };

    class PlayerCliQueryQuestCompletionNPCs
    {
        std::vector<int32> QuestID;
    };

    class PlayerCliSetPreferredCemetery
    {
        int32 CemeteryID = 0;
    };

    class PlayerCliDeleteCriteriaCheat
    {
        int32 CriteriaID = 0;
    };

    class PlayerCliRequestHonorStats
    {
        ObjectGuid TargetGUID;
    };

    class PlayerCliBattlefieldList
    {
        int32 ListID = 0;
    };

    class PlayerCliObjectUpdateFailed
    {
        ObjectGuid ObjectGUID;
    };

    class PlayerCliObjectUpdateRescued
    {
        ObjectGuid ObjectGUID;
    };

    class PlayerCurrencyCheat
    {
        std::string CheatArg;
    };

    class PlayerViolenceLevel
    {
        int8 ViolenceLevel = 0;
    };

    class PlayerGuildAwardChallengeCheat
    {
        int32 ChallengeType = 0;
    };

    class PlayerCliRuneRegenDebug
    {
        bool Enable = false;
    };

    class PlayerCliNoDamageVariance
    {
        bool Enable = false;
        ObjectGuid Target;
    };

    class PlayerCliStandStateChange
    {
        uint32 StandState = 0;
    };

    class PlayerCliUpdateMissileTrajectory
    {
        ObjectGuid Guid;
        uint16 MoveMsgID = 0;
        float Speed = 0.0f;
        Optional<CliMovementStatus> Status;
        float Pitch = 0.0f;
        Vector3 ImpactPos;
        int32 SpellID = 0;
        Vector3 FirePos;
    };

    class PlayerCliMissileTrajectoryCollision
    {
        ObjectGuid CasterGUID;
        Vector3 CollisionPos;
        int32 SpellID = 0;
        uint8 CastID = 0;
    };

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

    class TransmogrifyItem
    {
        Optional<ObjectGuid> SrcItemGUID;
        Optional<ObjectGuid> SrcVoidItemGUID;
        int32 ItemID = 0;
        uint32 Slot = 0;
    };

    class PlayerCliTransmogrifyItems
    {
        ObjectGuid Npc;
        std::vector<TransmogrifyItem> Items;
    };

    class PlayerCliSetSORLoadout
    {
        int32 CharacterLoadoutID = 0;
    };

    class PlayerCliShowPeriodicAuras
    {
        bool Enable = false;
    };

    class PlayerCliDumpConditionQuests
    {
        int32 ConditionID = 0;
    };

    class PlayerCliPhaseShowAreas
    {
        int32 PhaseID = 0;
    };

    class PlayerCliQueryObjPosition
    {
        bool ToClipboard = false;
        ObjectGuid Guid;
    };

    class PlayerCliQueryObjRotation
    {
        ObjectGuid Guid;
    };

    class PlayerCliUnlockVoidStorage
    {
        ObjectGuid Npc;
    };

    class PlayerCliQueryVoidStorage
    {
        ObjectGuid Npc;
    };

    class PlayerCliVoidStorageTransfer
    {
        std::vector<ObjectGuid> Withdrawals;
        std::vector<ObjectGuid> Deposits;
        ObjectGuid Npc;
    };

    class PlayerCliSwapVoidItem
    {
        ObjectGuid Npc;
        ObjectGuid VoidItem;
        uint32 DstSlot = 0;
    };

    class PlayerCliUnlearnSpecialization
    {
        uint8 SpecializationIndex = 0;
    };

    class PlayerCliClearRaidMarker
    {
        uint8 Index = 0;
    };

    class PlayerCliRequestGuildRewardsList
    {
        time_t CurrentVersion = time_t(0);
    };

    class PlayerCliRequestGuildPartyState
    {
        ObjectGuid GuildGUID;
    };

    class PlayerCliQueryCountdownTimer
    {
        uint32 TimerType = 0;
    };

    class PlayerCliSetSpecialization
    {
        uint32 SpecGroupIndex = 0;
    };

    class PlayerCliLearnTalents
    {
        std::vector<uint16> Talents;
    };

    class PlayerCliLearnPetSpecializationGroup
    {
        ObjectGuid PetGUID;
        uint32 SpecGroupIndex = 0;
    };

    class PlayerCliCancelModSpeedNoControlAuras
    {
        ObjectGuid TargetGUID;
    };

    class PlayerCliCancelAura
    {
        ObjectGuid CasterGUID;
        int32 SpellID = 0;
    };

    class PlayerCliCancelAuraCheat
    {
        int32 SpellID = 0;
    };

    class PlayerCliEnableDebugPerf
    {
        bool Enable = false;
    };

    class PlayerAddGuildXPCheat
    {
        int32 Xp = 0;
    };

    class PlayerCliDebugDrawServer
    {
        bool Enable = false;
    };

    class PlayerCliDebugAreaTriggers
    {
        bool Enable = false;
    };

    class PlayerCliSetPowerCheat
    {
        int32 Power = 0;
        uint8 PowerType = 0;
    };

    class PlayerCliCreateSceneObjectCheat
    {
        int32 EntryID = 0;
        CliSceneLocalScriptData ScriptData;
    };

    class PlayerCliDestroySceneObjectCheat
    {
        ObjectGuid SceneObjGUID;
    };

    class PlayerCliSendSceneObjectEventCheat
    {
        ObjectGuid SceneObjGUID;
        CliSceneObjectEvent SceneEvent;
    };

    class PlayerCliSendIsQuestCompleteCheat
    {
        int32 QuestID = 0;
    };

    class PlayerCliCalculateVehicleSeatOffsetCheat
    {
        ObjectGuid PassengerGUID;
        Vector3 PassengerRawPos;
    };

    class PlayerCliNeutralPlayerSelectFaction
    {
        int32 Faction = 0;
    };

    class PlayerCliGrantTitleCheat
    {
        int32 TitleID = 0;
        std::string TitleName;
    };

    class PlayerCliRemoveTitleCheat
    {
        std::string TitleName;
        int32 TitleID = 0;
    };

    class PlayerCliAreaTrigger
    {
        bool Entered = false;
        bool FromClient = false;
        int32 AreaTriggerID = 0;
    };

    class PlayerCliPetBattleRequestWild
    {
        PetBattleLocations Location;
        ObjectGuid TargetGUID;
    };

    class PlayerCliPetBattleWildLocationFail
    {
        ObjectGuid TargetGUID;
        Vector3 PlayerPos;
    };

    class PlayerCliPetBattleRequestPVP
    {
        PetBattleLocations Location;
        ObjectGuid OpponentCharacterID;
    };

    class PlayerCliPetBattleRequestUpdate
    {
        bool Canceled = false;
        ObjectGuid TargetGUID;
    };

    class PlayerCliLeavePetBattleQueue
    {
        CliRideTicket Ticket;
    };

    class PlayerCliBattlePetUpdateNotify
    {
        ObjectGuid BattlePetGUID;
    };

    class PlayerCliItemUpgradeCheat
    {
        int32 ItemID = 0;
        int32 ItemUpgradeID = 0;
    };

    class PlayerCliItemBindCheat
    {
        bool Bind = false;
        int32 ItemID = 0;
    };

    class PlayerCliGodMode
    {
        bool Enable = false;
    };

    class PlayerCliPetGodMode
    {
        bool Enable = false;
    };

    class PlayerCliIgnoreRequirementsCheat
    {
        bool Enable = false;
    };

    class PlayerCliIgnoreDiminishingReturnsCheat
    {
        bool Enable = false;
    };

    class PlayerCliLevelCheat
    {
        uint8 Level = 0;
    };

    class PlayerCliEffectiveLevelCheat
    {
        uint8 Level = 0;
    };

    class PlayerCliPetLevelCheat
    {
        uint8 Level = 0;
    };

    class PlayerCliCageBattlePet
    {
        ObjectGuid BattlePetGUID;
    };

    class PlayerCliSetStatCheat
    {
        uint32 Value = 0;
        uint8 Stat = 0;
    };

    class PlayerCliUseSkillCheat
    {
        uint32 SkillID = 0;
        uint32 Count = 0;
    };

    class PlayerCliSetSkillCheat
    {
        uint32 Level = 0;
        uint32 SkillID = 0;
    };

    class PlayerCliSetFactionCheat
    {
        uint32 FactionID = 0;
        int32 Level = 0;
    };

    class PlayerCliSetFactionUsingEnglishCheat
    {
        std::string Arguments;
    };

    class PlayerCliForceAction
    {
        uint8 Category = 0;
        bool OnSelf = false;
        bool Set = false;
    };

    class PlayerCliStartQuest
    {
        bool AbandonExisting = false;
        int32 QuestID = 0;
        bool AutoAccept = false;
    };

    class PlayerCliSetExplore
    {
        uint32 AreaID = 0;
    };

    class PlayerCliResetDailyQuest
    {
        int32 QuestID = 0;
    };

    class PlayerCliResetWeeklyQuest
    {
        int32 QuestID = 0;
    };

    class PlayerCliResetMonthlyQuest
    {
        int32 QuestID = 0;
    };

    class PlayerCliResetYearlyQuest
    {
        int32 QuestID = 0;
    };

    class PlayerCliFinishChallengeModeCheat
    {
        uint32 Time = 0;
    };

    class PlayerCliIncreaseCastTimeForSpell
    {
        int32 SpellID = 0;
    };

    class PlayerCliRespecTalentCheat
    {
        int32 Id = 0;
        uint8 RespecType = 0;
    };

    class PlayerCliConfirmRespecWipe
    {
        ObjectGuid RespecMaster;
        uint8 RespecType = 0;
    };

    class PlayerCliLootUnit
    {
        ObjectGuid Unit;
    };

    class PlayerCliLootItem
    {
        std::vector<LootRequest> Loot;
    };

    class PlayerCliMasterLootItem
    {
        std::vector<LootRequest> Loot;
        ObjectGuid Target;
    };

    class PlayerCliDoMasterLootRoll
    {
        ObjectGuid Object;
        uint8 LootListID = 0;
    };

    class PlayerCliCancelMasterLootRoll
    {
        ObjectGuid Object;
        uint8 LootListID = 0;
    };

    class PlayerCliLootRelease
    {
        ObjectGuid Object;
    };

    class PlayerCliLootRoll
    {
        ObjectGuid LootObj;
        uint8 LootListID = 0;
        uint8 RollType = 0;
    };

    class PlayerCliChallengeModeCheat
    {
        int32 ItemLevel = 0;
    };

    class PlayerCliPushItemsFromTreasure
    {
        uint32 TreasureID = 0;
        ItemContext LootItemContext;
    };

    class PlayerCliDisableAELooting
    {
        bool Disable = false;
    };

    class PlayerCliScenarioSetStep
    {
        int32 StepID = 0;
    };

    class PlayerCliScenarioStart
    {
        int32 ScenarioID = 0;
    };

    class PlayerCliScenePlaybackComplete
    {
        uint32 SceneInstanceID = 0;
    };

    class PlayerCliScenePlaybackCanceled
    {
        uint32 SceneInstanceID = 0;
    };

    class PlayerCliSceneTriggerEvent
    {
        uint32 SceneInstanceID = 0;
        std::string Event;
    };

    class PlayerCliSetDifficultyID
    {
        uint32 DifficultyID = 0;
    };

    class PlayerCliKeyboundOverride
    {
        uint16 OverrideID = 0;
    };

    class PlayerCliPetBattleQueueProposeMatchResult
    {
        bool Accepted = false;
    };

    class PlayerCliMailDelete
    {
        int32 DeleteReason = 0;
        int32 MailID = 0;
    };

    class PlayerCliSetAchievementsHidden
    {
        bool Hidden = false;
    };

    class PlayerCliUpgradeItem
    {
        ObjectGuid ItemMaster;
        ObjectGuid ItemGUID;
        int32 ContainerSlot = 0;
        int32 UpgradeID = 0;
        int32 Slot = 0;
    };

    class PlayerCliSetIgnoreRealmBundlePorts
    {
        bool Value = false;
    };

    class PlayerCliCompleteAccountAchievement
    {
        int32 AchievementID = 0;
    };

    class PlayerCliCompleteGuildAchievement
    {
        int32 AchievementID = 0;
    };

    class PlayerCliUnlearnMount
    {
        int32 MountID = 0;
    };

    class PlayerCliRemoveItemCollectionItem
    {
        int32 ItemCollectionType = 0;
        int32 ItemID = 0;
    };

    class PlayerCliSetMinItemLevel
    {
        int32 MinLevel = 0;
    };

    class PlayerCliSetMaxItemLevel
    {
        int32 MaxLevel = 0;
    };

    class PlayerCliRestockVendorCheat
    {
        ObjectGuid Target;
        bool StockAll = false;
    };

    class PlayerCliRequestVehicleSwitchSeat
    {
        ObjectGuid Vehicle;
        uint8 SeatIndex = 0;
    };

    class PlayerCliRideVehicleInteract
    {
        ObjectGuid Vehicle;
    };

    class PlayerCliEjectPassenger
    {
        ObjectGuid Passenger;
    };

    class PlayerCliCreateShadowPlayers
    {
        uint16 NumCopies = 0;
        int8 Type = 0;
    };

    class PlayerCliGetPowerRegenCheat
    {
        ObjectGuid Target;
        int32 PowerType = 0;
    };

    class PlayerCliGetHealthRegenCheat
    {
        ObjectGuid Target;
    };

    class PlayerCliUseCritterItem
    {
        ObjectGuid ItemGUID;
    };

    class PlayerCliInvisDumpCheat
    {
        ObjectGuid Target;
    };

    class PlayerCliInvisDetectDumpCheat
    {
        ObjectGuid Target;
    };

    class PlayerCliSetAccountCriteria
    {
        uint64 Quantity = 0;
        int32 CriteriaID = 0;
    };

    class PlayerCliSetGuildCriteria
    {
        uint64 Quantity = 0;
        int32 CriteriaID = 0;
    };

    class PlayerCliMatchesCondition
    {
        int32 ConditionID = 0;
    };

    class PlayerCliDeleteAccountAchievement
    {
        int32 AchievementID = 0;
    };

    class PlayerCliSetHealthSafe
    {
        ObjectGuid Target;
        int32 ProcType = 0;
        int32 Health = 0;
        int32 ProcSubType = 0;
    };

    class PlayerCliSetRulesetOverride
    {
        int32 RulesetOverride = 0;
    };

    class PlayerCliDebugAreaTriggerEvents
    {
        int32 Level = 0;
    };

    class PlayerCliDebugAreaTriggerUnitEvents
    {
        ObjectGuid Unit;
    };

    class PlayerCliDebugAreaTriggerServerShapes
    {
        bool Enable = false;
    };

    class PlayerCliShowZonesCheat
    {
        bool Show = false;
    };

    class PlayerCliCDBLookup
    {
        std::string Searchstd::string;
        bool ReturnLocalizedstd::strings = false;
        int32 Locale = 0;
        bool OnlySearchLocalizedFields = false;
    };

    class PlayerCliGameSpeedSet
    {
        float Speed = 0.0f;
    };

    class PlayerCliLearnSpellCheat
    {
        int32 SpellID = 0;
    };

    class PlayerCliMakeMonsterAttackGUID
    {
        ObjectGuid Victim;
        ObjectGuid Attacker;
    };

    class PlayerCliAttackSwing
    {
        ObjectGuid Victim;
    };

    class PlayerCliDestroyMonster
    {
        ObjectGuid Monster;
    };

    class PlayerCliDebugActionsStart
    {
        ObjectGuid Target;
        int32 SpawnGroupID = 0;
        int32 CreatureID = 0;
    };

    class PlayerCliForceSayCheat
    {
        ObjectGuid Target;
        int32 TextID = 0;
    };

    class PlayerCliCreateMonster
    {
        int32 EntryID = 0;
        Vector3 Offset;
    };

    class PlayerCliTargetCast
    {
        int32 SpellID = 0;
        ObjectGuid CastTarget;
        ObjectGuid TargetGUID;
        bool CreatureAICast = false;
    };

    class PlayerCliTargetScriptCast
    {
        ObjectGuid TargetGUID;
        int32 SpellID = 0;
    };

    class PlayerCliListTargets
    {
        ObjectGuid UnitGUID;
    };

    class PlayerCancelChannelling
    {
        int32 ChannelSpell = 0;
    };

    class PlayerCliXpCheat
    {
        int32 DesiredXP = 0;
    };

    class PlayerCliUnitAnimTierCheat
    {
        ObjectGuid TargetGUID;
        int32 NewTier = 0;
    };

    class PlayerCliGMTeachSpell
    {
        ObjectGuid TargetGUID;
        int32 SpellID = 0;
    };

    class PlayerCliGMUnteachSpell
    {
        ObjectGuid TargetGUID;
        int32 SpellID = 0;
    };

    class PlayerCliQueryCreature
    {
        uint32 CreatureID = 0;
    };

    class PlayerCliQueryGameObject
    {
        ObjectGuid Guid;
        uint32 GameObjectID = 0;
    };

    class PlayerCliQueryNPCText
    {
        ObjectGuid Guid;
        uint32 TextID = 0;
    };

    class PlayerCliQueryQuestInfo
    {
        ObjectGuid QuestGiver;
        uint32 QuestID = 0;
    };

    class PlayerCliQueryPageText
    {
        ObjectGuid ItemGUID;
        uint32 PageTextID = 0;
    };

    class PlayerCliQueryPetName
    {
        ObjectGuid UnitGUID;
    };

    class PlayerCliQueryBattlePetName
    {
        ObjectGuid BattlePetID;
        ObjectGuid UnitGUID;
    };

    class PlayerCliQueryPetition
    {
        ObjectGuid ItemGUID;
        uint32 PetitionID = 0;
    };

    class PlayerCliChangeCellZone
    {
        uint8 ZoneID = 0;
    };

    class PlayerCliDebugPassiveAura
    {
        int32 SpellID = 0;
        ObjectGuid Target;
        bool Add = false;
    };

    class PlayerCliPerformActionSetCheat
    {
        ObjectGuid Target;
        int32 ActionSetID = 0;
    };

    class PlayerCliRequestPlayedTime
    {
        bool TriggerScriptEvent = false;
    };

    class PlayerCliRunScript
    {
        std::string Text;
        ObjectGuid Target;
    };

    class PlayerCliCreateItemCheat
    {
        bool BattlePayLocked = false;
        bool AutoEquip = false;
        std::string Context;
        int32 Count = 0;
        uint32 EntryID = 0;
    };

    class PlayerCliSetTitle
    {
        int32 Title = 0;
    };

    class PlayerCliCooldownCheat
    {
        ObjectGuid Guid;
        uint8 CheatCode = 0;
    };

    class PlayerCliDebugAIState
    {
        ObjectGuid Unit;
    };

    class PlayerCliAdvanceSpawnTime
    {
        uint32 Seconds = 0;
    };

    class PlayerCliQueryVehicleStatus
    {
        ObjectGuid Target;
    };

    class PlayerCliGameTimeSet
    {
        uint32 NewTime = 0;
    };

    class PlayerCliGmVision
    {
        bool Enable = false;
    };

    class PlayerCliGMPhaseDump
    {
        ObjectGuid Target;
    };

    class PlayerCliGMSpawnTrackerDump
    {
        ObjectGuid Target;
    };

    class PlayerCliDestroyItem
    {
        uint32 Count = 0;
        uint8 SlotNum = 0;
        uint8 ContainerId = 0;
    };

    class PlayerCliSummonMob
    {
        ObjectGuid TargetGUID;
    };

    class PlayerCliUberInvis
    {
        int8 Action = 0;
    };

    class PlayerCliCreateGameObject
    {
        int32 EntryID = 0;
    };

    class PlayerCliGetMirrorImageData
    {
        ObjectGuid UnitGUID;
        int32 DisplayID = 0;
    };

    class MissileTrajectoryRequest
    {
        float Pitch = 0.0f;
        float Speed = 0.0f;
    };

    class SpellWeight
    {
        SpellweightTokenTypes Type;
        int32 ID = 0;
        uint32 Quantity = 0;
    };

    class SpellCastRequest
    {
        uint8 CastID = 0;
        int32 SpellID = 0;
        int32 Misc = 0;
        uint8 SendCastFlags = 0;
        SpellTargetData Target;
        MissileTrajectoryRequest MissileTrajectory;
        Optional<CliMovementStatus> MoveUpdate;
        std::vector<SpellWeight> Weight;
    };

    class PlayerCliUseItem
    {
        uint8 PackSlot = 0;
        SpellCastRequest Cast;
        uint8 Slot = 0;
        ObjectGuid CastItem;
    };

    class PlayerCliUseToy
    {
        SpellCastRequest Cast;
        int32 ItemID = 0;
    };

    class PlayerCliPetCastSpell
    {
        ObjectGuid PetGUID;
        SpellCastRequest Cast;
    };

    class PlayerCliCastSpell
    {
        SpellCastRequest Cast;
    };

    class PlayerCliCancelCast
    {
        int32 SpellID = 0;
        uint8 CastID = 0;
    };

    class PlayerCliForceAnim
    {
        ObjectGuid Target;
        std::string Arguments;
    };

    class PlayerCliChoiceResponse
    {
        int32 ChoiceID = 0;
        int32 ResponseID = 0;
    };

    class PlayerCliSetLFGBonusFactionID
    {
        int32 FactionID = 0;
    };

    class PlayerCliCheatTestFactory
    {
        uint32 Msgid = 0;
    };

    class PlayerCliCheatSetUnitLootSeed
    {
        ObjectGuid Unit;
        uint32 LootSeed = 0;
    };

    class PlayerCliCheatItemLevelDelta
    {
        int32 ItemLevelDelta = 0;
    };

    class PlayerCliDirtyMoney
    {
        uint64 Amount = 0;
    };

    class PlayerSaveGuildEmblem
    {
        ObjectGuid Vendor;
        int32 Bg = 0;
        int32 EStyle = 0;
        int32 EColor = 0;
        int32 BColor = 0;
        int32 BStyle = 0;
    };

    class PlayerTabardVendorActivate
    {
        ObjectGuid Vendor;
    };

    class PlayerProgressiveEventCheat
    {
        ProgressiveEventCheat Type;
        int32 ItemID = 0;
        int32 Count = 0;
        int32 EventID = 0;
    };

    class PlayerCliSetPVP
    {
        bool EnablePVP = false;
    };

    class PlayerCliDumpEncounter
    {
        Optional<int32> DungeonEncounterID;
    };

    class PlayerCliSetEncounterVar
    {
        int32 DungeonEncounterID = 0;
        std::string VarName;
        bool Attempt = false;
        float VarValue = 0.0f;
    };

    class PlayerCliBattlemasterHello
    {
        ObjectGuid Unit;
    };

    class PlayerCliDebugGroupSize
    {
        uint32 OverrideGroupSize = 0;
    };

    class PlayerCliDebugTimeWalkerLevels
    {
        uint32 PlayerLevel = 0;
        uint32 ItemLevel = 0;
    };

    class PlayerCliSetEncounterProfiler
    {
        bool Enable = false;
        int32 EncounterID = 0;
        std::string MailTo;
    };

    class PlayerCliSetAdvancedCombatLogging
    {
        bool Enable = false;
    };

    class PlayerCliSpawnedMOCheat
    {
        float Angle = 0.0f;
        bool Enabled = false;
        std::string FileName;
        Vector3 Pos;
        uint32 SpawnedMOIndex = 0;
    };

    class PlayerCliResetPersonalPhasesCheat
    {
        bool AllPhases = false;
        std::vector<uint16> PhaseIDs;
    };

    class PlayerCliSeamlessTransferCheat
    {
        int32 TransferID = 0;
    };

    class PlayerCliGarrisonCreateCheat
    {
        int32 GarrSiteID = 0;
    };

    class PlayerCliGarrisonDeleteCheat
    {
        int32 GarrSiteID = 0;
    };

    class PlayerCliGarrisonSetLevelCheat
    {
        int32 Level = 0;
    };

    class PlayerCliUpgradeGarrison
    {
        ObjectGuid NpcGUID;
    };

    class PlayerCliGarrisonPlaceBuildingCheat
    {
        bool Activate = false;
        int32 BuildingID = 0;
        int32 PlotInstanceID = 0;
    };

    class PlayerCliGarrisonRemoveBuildingCheat
    {
        int32 PlotInstanceID = 0;
    };

    class PlayerCliGarrisonUpgradeBuildingCheat
    {
        int32 PlotInstanceID = 0;
        bool Immediate = false;
    };

    class PlayerCliGarrisonLearnBuildingSpecializationCheat
    {
        int32 SpecializationID = 0;
    };

    class PlayerCliGarrisonSetActiveBuildingSpecialization
    {
        ObjectGuid NpcGUID;
        int32 PlotInstanceID = 0;
        int32 SpecializationID = 0;
    };

    class PlayerCliGarrisonSetActiveBuildingSpecializationCheat
    {
        int32 PlotInstanceID = 0;
        int32 SpecializationID = 0;
    };

    class PlayerCliGarrisonLearnBlueprintCheat
    {
        int32 BuildingID = 0;
    };

    class PlayerCliGarrisonPurchaseBuilding
    {
        ObjectGuid NpcGUID;
        int32 BuildingID = 0;
        int32 PlotInstanceID = 0;
    };

    class PlayerCliGarrisonSetBuildingActive
    {
        int32 PlotInstanceID = 0;
    };

    class PlayerCliGarrisonForceBuildingActive
    {
        int32 PlotInstanceID = 0;
    };

    class PlayerCliGarrisonAddFollowerXPCheat
    {
        uint64 FollowerDBID = 0;
        int32 XpAmount = 0;
    };

    class PlayerCliGarrisonSetFollowerItemLevelCheat
    {
        uint64 FollowerDBID = 0;
        int32 ItemLevelArmor = 0;
        int32 ItemLevelWeapon = 0;
    };

    class PlayerCliGarrisonAssignFollowerToBuilding
    {
        ObjectGuid NpcGUID;
        uint64 FollowerDBID = 0;
        int32 PlotInstanceID = 0;
    };

    class PlayerCliGarrisonRemoveFollowerFromBuilding
    {
        ObjectGuid NpcGUID;
        uint64 FollowerDBID = 0;
    };

    class PlayerCliOpenShipmentNPC
    {
        ObjectGuid NpcGUID;
    };

    class PlayerCliGetShipmentInfo
    {
        ObjectGuid NpcGUID;
    };

    class PlayerCliGetShipmentsOfType
    {
        int32 ContainerID = 0;
    };

    class PlayerCliCreateShipment
    {
        ObjectGuid NpcGUID;
    };

    class PlayerCliGetShipmentsOfTypeCheat
    {
        int32 ContainerID = 0;
    };

    class PlayerCliCreateShipmentCheat
    {
        int32 ShipmentRecID = 0;
    };

    class PlayerCliCompleteShipmentCheat
    {
        uint64 ShipmentID = 0;
    };

    class PlayerCliCompleteShipment
    {
        uint64 ShipmentID = 0;
        ObjectGuid NpcGUID;
    };

    class PlayerCliCompleteAllReadyShipments
    {
        ObjectGuid ShipmentGameObjectGUID;
    };

    class GdfSimPlayer
    {
        ObjectGuid Guid;
        float GdfRating = 0.0f;
        float GdfVariance = 0.0f;
        int32 PersonalRating = 0;
        bool Team = false;
    };

    class PlayerCliGdfSimCheat
    {
        float GdfUnitBlend = 0.0f;
        float GdfToEloMultiplier = 0.0f;
        float Beta2 = 0.0f;
        int32 NoShowPenalty0 = 0;
        int32 NoShowPenalty1 = 0;
        float MinVariance = 0.0f;
        bool Winner = false;
        std::vector<GdfSimPlayer> Players;
        float Mean = 0.0f;
        bool BoostType = false;
    };

    class PlayerCliShowAdvertsCheat
    {
        uint32 DetailLevel = 0;
        float Radius = 0.0f;
        bool On = false;
    };

    class PlayerCliShowBrain
    {
        int32 Level = 0;
        bool All = false;
        ObjectGuid Target;
    };

    class PlayerCliTest128BitGuids
    {
        int32128 Guid;
    };

    class PlayerCliGetTrophyList
    {
        int32 TrophyTypeID = 0;
    };

    class PlayerCliReplaceTrophy
    {
        ObjectGuid TrophyGUID;
        int32 NewTrophyID = 0;
    };

    class PlayerCliGarrisonAddUniqueFollowerCheat
    {
        int32 GarrFollowerID = 0;
    };

    class PlayerCliGarrisonRemoveFollowerCheat
    {
        uint64 FollowerDBID = 0;
    };

    class PlayerCliGarrisonAddMissionCheat
    {
        int32 MissionRecID = 0;
    };

    class PlayerCliGarrisonStartMission
    {
        ObjectGuid NpcGUID;
        std::vector<uint64> FollowerDBIDs;
        int32 MissionRecID = 0;
    };

    class PlayerCliGarrisonCompleteMission
    {
        ObjectGuid NpcGUID;
        int32 MissionRecID = 0;
    };

    class PlayerCliGarrisonCompleteMissionCheat
    {
        int32 MissionRecID = 0;
    };

    class PlayerCliGarrisonMissionBonusRoll
    {
        ObjectGuid NpcGUID;
        int32 MissionRecID = 0;
        int32 BonusIndex = 0;
    };

    class PlayerCliItemTextQuery
    {
        ObjectGuid Id;
    };

    class PlayerCliOpenItem
    {
        uint8 Slot = 0;
        uint8 PackSlot = 0;
    };

    class PlayerCliReadItem
    {
        uint8 Slot = 0;
        uint8 PackSlot = 0;
    };

    class PlayerCliChangeBagSlotFlag
    {
        bool On = false;
        uint32 FlagToChange = 0;
        uint32 BagIndex = 0;
    };

    class PlayerCliSetBackpackAutosortDisabled
    {
        bool Disable = false;
    };

    class PlayerCliSetBankAutosortDisabled
    {
        bool Disable = false;
    };

    class PlayerCliSetBankBagSlotAutosortDisabled
    {
        bool Disable = false;
        uint32 BagIndex = 0;
    };

    class PlayerCliStartConversation
    {
        int32 ConversationID = 0;
    };

    class PlayerCliStopConversation
    {
        ObjectGuid Conversation;
    };

    class PlayerCliDebugTreasure
    {
        bool Enable = false;
    };

    class PlayerCliItemBonusDebug
    {
        bool Enable = false;
    };

    class PlayerCliSetWorldState
    {
        int32 VariableID = 0;
        int32 Value = 0;
    };

    class PlayerCliSendEvent
    {
        uint32 EventID = 0;
    };

    class PlayerCliSendLocalEvent
    {
        ObjectGuid TargetGUID;
        int32 EventID = 0;
    };

    class PlayerCliSendGeneralTrigger
    {
        ObjectGuid TargetGUID;
        int32 EventID = 0;
    };

    class PlayerCliSendCombatTrigger
    {
        ObjectGuid TargetGUID;
        int32 EventID = 0;
    };

    class PlayerCliSendTextEmote
    {
        ObjectGuid Target;
        int32 EmoteID = 0;
        int32 SoundIndex = 0;
    };

    class PlayerCliSetSheathed
    {
        int32 CurrentSheathState = 0;
        bool Animate = false;
    };

    class PlayerCliTestDropRate
    {
        uint32 TreasureID = 0;
        Optional<uint32> ItemQuality;
        Optional<int32> ClassID;
        Optional<uint32> ItemID;
        Optional<int32> SubClassID;
        int32 LootLevel = 0;
    };

    class PlayerCliPetSetAction
    {
        ObjectGuid PetGUID;
        uint32 Action = 0;
        uint32 Index = 0;
    };

    class PlayerCliPetAction
    {
        ObjectGuid PetGUID;
        ObjectGuid TargetGUID;
        Vector3 ActionPosition;
        uint32 Action = 0;
    };

    class PlayerCliPetStopAttack
    {
        ObjectGuid PetGUID;
    };

    class PlayerCliPetAbandon
    {
        ObjectGuid Pet;
    };

    class PlayerCliPetCancelAura
    {
        ObjectGuid PetGUID;
        int32 SpellID = 0;
    };

    class PlayerCliPetSpellAutocast
    {
        ObjectGuid PetGUID;
        bool AutocastEnabled = false;
        int32 SpellID = 0;
    };

    class PlayerCliRequestStabledPets
    {
        ObjectGuid StableMaster;
    };

    class PlayerCliTalkToGossip
    {
        ObjectGuid GossipUnit;
    };

    class PlayerCliGossipSelectOption
    {
        ObjectGuid GossipUnit;
        int32 GossipIndex = 0;
        int32 GossipID = 0;
        std::string PromotionCode;
    };

    class PlayerCliSpellClick
    {
        ObjectGuid SpellClickUnitGUID;
        bool TryAutoDismount = false;
    };

    class PlayerCliQuestGiverHello
    {
        ObjectGuid QuestGiverGUID;
    };

    class PlayerCliQuestGiverQueryQuest
    {
        int32 QuestID = 0;
        ObjectGuid QuestGiverGUID;
        bool RespondToGiver = false;
    };

    class PlayerCliQuestGiverAutoLaunch
    {
        ObjectGuid QuestGiverGUID;
        int32 QuestID = 0;
    };

    class PlayerCliQuestGiverAcceptQuest
    {
        int32 QuestID = 0;
        ObjectGuid QuestGiverGUID;
        bool StartCheat = false;
    };

    class PlayerCliQuestGiverCompleteQuest
    {
        bool FromScript = false;
        int32 QuestID = 0;
        ObjectGuid QuestGiverGUID;
    };

    class PlayerCliQuestGiverCancel
    {
        ObjectGuid QuestGiverGUID;
        int32 QuestID = 0;
    };

    class PlayerCliQuestGiverChooseReward
    {
        ObjectGuid QuestGiverGUID;
        int32 QuestID = 0;
        int32 ItemChoiceID = 0;
    };

    class PlayerCliQuestGiverRequestReward
    {
        ObjectGuid QuestGiverGUID;
        int32 QuestID = 0;
    };

    class PlayerCliQuestGiverStatusQuery
    {
        ObjectGuid QuestGiverGUID;
    };

    class PlayerCliQuestConfirmAccept
    {
        int32 QuestID = 0;
    };

    class PlayerCliPushQuestToParty
    {
        int32 QuestID = 0;
    };

    class PlayerCliQuestPushResult
    {
        ObjectGuid TargetGUID;
        int32 QuestID = 0;
        uint8 Result = 0;
    };

    class PlayerCliListInventory
    {
        ObjectGuid VendorGUID;
    };

    class PlayerCliSellItem
    {
        ObjectGuid ItemGUID;
        ObjectGuid VendorGUID;
        int32 Amount = 0;
    };

    class PlayerCliBuyItem
    {
        ObjectGuid VendorGUID;
        ItemInstance Item;
        uint32 Muid = 0;
        uint32 Slot = 0;
        uint8 ItemType = 0;
        int32 Quantity = 0;
        ObjectGuid ContainerGUID;
    };

    class PlayerCliBuyBackItem
    {
        ObjectGuid VendorGUID;
        uint32 Slot = 0;
    };

    class PlayerCliTaxiNodeStatusQuery
    {
        ObjectGuid UnitGUID;
    };

    class PlayerCliEnableTaxiNode
    {
        ObjectGuid Unit;
    };

    class PlayerCliTaxiQueryAvailableNodes
    {
        ObjectGuid Unit;
    };

    class PlayerCliActivateTaxi
    {
        ObjectGuid Vendor;
        uint32 StartNode = 0;
        uint32 DestNode = 0;
    };

    class PlayerCliActivateTaxiExpress
    {
        ObjectGuid Unit;
        std::vector<uint32> PathNodes;
    };

    class PlayerCliTrainerList
    {
        ObjectGuid TrainerGUID;
    };

    class PlayerCliTrainerBuySell
    {
        ObjectGuid TrainerGUID;
        int32 TrainerID = 0;
        int32 SpellID = 0;
    };

    class PlayerCliSpiritHealerActivate
    {
        ObjectGuid Healer;
    };

    class PlayerCliAreaSpiritHealerQuery
    {
        ObjectGuid HealerGuid;
    };

    class PlayerCliAreaSpiritHealerQueue
    {
        ObjectGuid HealerGuid;
    };

    class PlayerCliBinderActivate
    {
        ObjectGuid Binder;
    };

    class PlayerCliBankerActivate
    {
        ObjectGuid Banker;
    };

    class PlayerCliBuyBankSlot
    {
        ObjectGuid Banker;
    };

    class PlayerCliGuildBankActivate
    {
        ObjectGuid Banker;
        bool FullUpdate = false;
    };

    class PlayerCliGuildBankSwapItems
    {
        uint8 BankSlot = 0;
        int32 StackCount = 0;
        ObjectGuid Banker;
        bool AutoStore = false;
        uint8 ContainerItemSlot = 0;
        uint32 ItemID = 0;
        uint8 ToSlot = 0;
        uint8 BankTab1 = 0;
        uint8 BankTab = 0;
        int32 BankItemCount = 0;
        uint8 ContainerSlot = 0;
        uint32 ItemID1 = 0;
        bool BankOnly = false;
        uint8 BankSlot1 = 0;
    };

    class PlayerCliGuildBankQueryTab
    {
        ObjectGuid Banker;
        bool FullUpdate = false;
        uint8 Tab = 0;
    };

    class PlayerCliGuildBankBuyTab
    {
        ObjectGuid Banker;
        uint8 BankTab = 0;
    };

    class PlayerCliGuildBankUpdateTab
    {
        std::string Icon;
        std::string Name;
        uint8 BankTab = 0;
        ObjectGuid Banker;
    };

    class PlayerCliGuildBankDepositMoney
    {
        uint64 Money = 0;
        ObjectGuid Banker;
    };

    class PlayerCliGuildBankWithdrawMoney
    {
        ObjectGuid Banker;
        uint64 Money = 0;
    };

    class PlayerCliPetitionShowList
    {
        ObjectGuid PetitionUnit;
    };

    class PlayerCliPetitionBuy
    {
        ObjectGuid Unit;
        std::string Title;
    };

    class PlayerCliPetitionShowSignatures
    {
        ObjectGuid Item;
    };

    class PlayerCliAuctionHelloRequest
    {
        ObjectGuid Auctioneer;
    };

    class ClientAuctionItemForSale
    {
        ObjectGuid Guid;
        uint32 UseCount = 0;
    };

    class PlayerCliAuctionSellItem
    {
        uint64 BuyoutPrice = 0;
        std::vector<ClientAuctionItemForSale> Items;
        ObjectGuid Auctioneer;
        uint64 MinBid = 0;
        uint32 RunTime = 0;
    };

    class PlayerCliAuctionRemoveItem
    {
        ObjectGuid Auctioneer;
        int32 AuctionItemID = 0;
    };

    class PlayerCliAuctionListItems
    {
        ObjectGuid Auctioneer;
        uint8 SortCount = 0;
        uint8 MaxLevel = 0;
        uint32 Offset = 0;
        int32 ItemClass = 0;
        uint8 MinLevel = 0;
        int32 InvType = 0;
        int32 Quality = 0;
        int32 ItemSubclass = 0;
        bool ExactMatch = false;
        std::string Name;
        bool OnlyUsable = false;
        Data Sorts;
    };

    class PlayerCliAuctionReplicateItems
    {
        ObjectGuid Auctioneer;
        uint32 ChangeNumberCursor = 0;
        uint32 Count = 0;
        uint32 ChangeNumberGlobal = 0;
        uint32 ChangeNumberTombstone = 0;
    };

    class PlayerCliAuctionListOwnerItems
    {
        ObjectGuid Auctioneer;
        uint32 Offset = 0;
    };

    class PlayerCliAuctionListBidderItems
    {
        uint32 Offset = 0;
        std::vector<uint32> AuctionItemIDs;
        ObjectGuid Auctioneer;
    };

    class PlayerCliAuctionPlaceBid
    {
        ObjectGuid Auctioneer;
        uint64 BidAmount = 0;
        int32 AuctionItemID = 0;
    };

    class PlayerCliReclaimCorpse
    {
        ObjectGuid CorpseGUID;
    };

    class PlayerCliTriggerMovieCheat
    {
        uint32 MovieID = 0;
    };

    class PlayerCliSetFactionAtWar
    {
        uint8 FactionIndex = 0;
    };

    class PlayerCliSetFactionNotAtWar
    {
        uint8 FactionIndex = 0;
    };

    class PlayerCliSetFactionInactive
    {
        bool State = false;
        int32 Index = 0;
    };

    class PlayerCliSetWatchedFaction
    {
        int32 Index = 0;
    };

    class PlayerCliDuelResponse
    {
        ObjectGuid ArbiterGUID;
        bool Accepted = false;
    };

    class PlayerCliUnlearnSpell
    {
        int32 SpellID = 0;
    };

    class PlayerCliUnlearnSkill
    {
        int32 SkillLine = 0;
    };

    class PlayerCliAICheat
    {
        bool On = false;
    };

    class PlayerCliFarSight
    {
        bool Enable = false;
    };

    class PlayerCliEnableDamageLog
    {
        bool On = false;
    };

    class PlayerCliSetDurabilityCheat
    {
        ObjectGuid Item;
        uint32 Durability = 0;
    };

    class PlayerCliSocketGems
    {
        ObjectGuid GemItem[3] = { };
        ObjectGuid ItemGuid;
    };

    class PlayerCliRepairItem
    {
        ObjectGuid NpcGUID;
        bool UseGuildBank = false;
        ObjectGuid ItemGUID;
    };

    class PlayerCliShowingHelm
    {
        bool ShowHelm = false;
    };

    class PlayerCliShowingCloak
    {
        bool ShowCloak = false;
    };

    class PlayerCliWeatherSpeedCheat
    {
        float NewSpeed = 0.0f;
    };

    class PlayerCliGameObjUse
    {
        ObjectGuid GameObjectGUID;
    };

    class PlayerCliGameObjReportUse
    {
        ObjectGuid GameObjectGUID;
    };

    class PlayerCliCancelTempEnchantment
    {
        int32 Slot = 0;
    };

    class PlayerCliSetTaxiBenchmarkMode
    {
        bool Enable = false;
    };

    class PlayerCliReportPvPPlayerAFK
    {
        ObjectGuid Offender;
    };

    class PlayerCliAlterAppearance
    {
        int32 NewFacialHair = 0;
        int32 NewSkinColor = 0;
        int32 NewHairColor = 0;
        int32 NewHairStyle = 0;
    };

    class PlayerCliOptOutOfLoot
    {
        bool OptOutOfLoot = false;
    };

    class PlayerCliGrantLevel
    {
        ObjectGuid Target;
    };

    class PlayerCliSetGrantableLevels
    {
        uint32 Levels = 0;
    };

    class PlayerCliAcceptLevelGrant
    {
        ObjectGuid Granter;
    };

    class PlayerCliTotemDestroyed
    {
        ObjectGuid TotemGUID;
        uint8 Slot = 0;
    };

    class PlayerCliDismissCritter
    {
        ObjectGuid CritterGUID;
    };

    class PlayerCliSetRuneCount
    {
        uint8 Frost = 0;
        uint8 Unholy = 0;
        uint8 Blood = 0;
    };

    class PlayerCliSetRuneCooldown
    {
        float Blood = 0.0f;
        float Unholy = 0.0f;
        float Chromatic = 0.0f;
        float Frost = 0.0f;
    };

    class PlayerCliNoSpellVariance
    {
        ObjectGuid Target;
        bool Enable = false;
    };

    class PlayerCliQueryServerBuckData
    {
        bool AllClusters = false;
        uint8 ClusterID = 0;
        uint32 RequestID = 0;
        uint8 Mpid = 0;
    };

    class PlayerCliDumpObjects
    {
        uint32 Filter = 0;
    };

    class PlayerCliSetGlyphSlot
    {
        uint16 GlyphSlot = 0;
        uint8 Slot = 0;
    };

    class PlayerCliSetGlyphCheat
    {
        uint16 Glyph = 0;
        uint8 Slot = 0;
    };

    class PlayerCliQueryInspectAchievements
    {
        ObjectGuid Guid;
    };

    class PlayerCliCompleteAchievementCheat
    {
        int32 AchievementID = 0;
        bool Complete = false;
    };

    class PlayerCliSetCriteriaCheat
    {
        uint64 Quantity = 0;
        uint32 CriteriaID = 0;
    };

    class PlayerCliDestroyItems
    {
        bool SkipEquipped = false;
    };

    class PlayerCliServerInfoQuery
    {
        std::string Category;
    };

    class PlayerCliSetBreath
    {
        uint8 BreathValue = 0;
    };

    class PlayerCliSaveEquipmentSet
    {
        EquipmentSetData Set;
    };

    class PlayerCliDeleteEquipmentSet
    {
        uint64 ID = 0;
    };

    class PlayerCliInstanceLockResponse
    {
        bool AcceptLock = false;
    };

    class PlayerCliDebugServerGeo
    {
        uint32 ShowPathingGeoDist = 0;
        bool ShowSurfaceLinks = false;
        bool Enabled = false;
        bool ShowDoors = false;
    };

    class PlayerCliGMSetPhase
    {
        std::vector<uint16> PhaseID;
    };

    class PlayerCliGMPhaseAdd
    {
        std::vector<uint16> PhaseID;
    };

    class PlayerCliGMPhaseRemove
    {
        std::vector<uint16> PhaseID;
    };

    class PlayerCliLowLevelRaid
    {
        bool Enable = false;
    };

    class PlayerCliSetCharacterModel
    {
        int32 DisplayID = 0;
    };

    class PlayerCliSetCharacterCustomization
    {
        int32 VariationValue = 0;
        int32 VariationIndex = 0;
    };

    class PlayerCliSetCurrencyCheat
    {
        int32 Quantity = 0;
        int32 Type = 0;
    };

    class PlayerCliSetFactionVisibleCheat
    {
        bool Visible = false;
        int32 FactionID = 0;
    };

    class PlayerCliDeclineGuildInvites
    {
        bool Allow = false;
    };

    class PlayerCliBattlemasterJoin
    {
        bool JoinAsGroup = false;
        uint8 Roles = 0;
        uint64 QueueID = 0;
        int32 BlacklistMap[2] = { };
    };

    class PlayerCliBattlemasterJoinArena
    {
        uint8 TeamSizeIndex = 0;
    };

    class PlayerCliBattlemasterJoinArenaSkirmish
    {
        uint8 Roles = 0;
        uint8 Bracket = 0;
        bool JoinAsGroup = false;
    };

    class PlayerCliBattlefieldPort
    {
        CliRideTicket Ticket;
        bool AcceptedInvite = false;
    };

    class PlayerCliRepopRequest
    {
        bool CheckInstance = false;
    };

    class PlayerCliSetSelection
    {
        ObjectGuid Selection;
    };

    class PlayerCliInspect
    {
        ObjectGuid Target;
    };

    class PlayerCliBlackMarketOpen
    {
        ObjectGuid NpcGUID;
    };

    class PlayerCliBlackMarketRequestItems
    {
        ObjectGuid NpcGUID;
        time_t LastUpdateID = time_t(0);
    };

    class PlayerCliBlackMarketBidOnItem
    {
        ObjectGuid NpcGUID;
        ItemInstance Item;
        int32 MarketID = 0;
        uint64 BidAmount = 0;
    };

    class PlayerCliQuestLogRemoveQuest
    {
        uint8 Entry = 0;
    };

    class PlayerCliGetItemPurchaseData
    {
        ObjectGuid ItemGUID;
    };

    class PlayerCliItemPurchaseRefund
    {
        ObjectGuid ItemGUID;
    };

    class PlayerCliSetActionBarToggles
    {
        uint8 Mask = 0;
    };

    class PlayerCliSignPetition
    {
        ObjectGuid PetitionGUID;
        uint8 Choice = 0;
    };

    class PlayerCliDeclinePetition
    {
        ObjectGuid PetitionGUID;
    };

    class PlayerCliTurnInPetition
    {
        ObjectGuid Item;
    };

    class PlayerCliMailGetList
    {
        ObjectGuid Mailbox;
    };

    class PlayerCliMailTakeMoney
    {
        ObjectGuid Mailbox;
        uint64 Money = 0;
        int32 MailID = 0;
    };

    class PlayerCliMailTakeItem
    {
        ObjectGuid Mailbox;
        int32 AttachID = 0;
        int32 MailID = 0;
    };

    class PlayerCliMailMarkAsRead
    {
        bool BiReceipt = false;
        int32 MailID = 0;
        ObjectGuid Mailbox;
    };

    class PlayerCliMailCreateTextItem
    {
        ObjectGuid Mailbox;
        int32 MailID = 0;
    };

    class SetPvpRankCheat
    {
        int32 Rank = 0;
    };

    class AddPvpMedalCheat
    {
        int32 Medal = 0;
    };

    class DelPvpMedalCheat
    {
        int32 Medal = 0;
    };

    class PlayerCliSetLootSpecialization
    {
        uint32 SpecID = 0;
    };

    class PlayerCliGMSetXPGainEnabled
    {
        bool Enable = false;
    };

    class PlayerCliEmote
    {
        uint32 EmoteID = 0;
    };

    class PlayerCliTriggerCinematicCheat
    {
        uint32 CinematicID = 0;
    };

    class InvItem
    {
        uint8 ContainerSlot = 0;
        uint8 Slot = 0;
    };

    class InvUpdate
    {
        std::vector<InvItem> Items;
    };

    class PlayerCliWrapItem
    {
        InvUpdate Inv;
    };

    class EquipmentSetItem
    {
        ObjectGuid Item;
        uint8 ContainerSlot = 0;
        uint8 Slot = 0;
    };

    class PlayerCliUseEquipmentSet
    {
        InvUpdate Inv;
        EquipmentSetItem Items[19] = { };
    };

    class PlayerCliAutostoreBankItem
    {
        InvUpdate Inv;
        uint8 Slot = 0;
        uint8 PackSlot = 0;
    };

    class PlayerCliAutobankItem
    {
        uint8 PackSlot = 0;
        InvUpdate Inv;
        uint8 Slot = 0;
    };

    class PlayerCliAutoEquipItem
    {
        uint8 Slot = 0;
        InvUpdate Inv;
        uint8 PackSlot = 0;
    };

    class PlayerCliAutoStoreBagItem
    {
        uint8 ContainerSlotB = 0;
        InvUpdate Inv;
        uint8 ContainerSlotA = 0;
        uint8 SlotA = 0;
    };

    class PlayerCliSwapItem
    {
        InvUpdate Inv;
        uint8 SlotA = 0;
        uint8 ContainerSlotB = 0;
        uint8 SlotB = 0;
        uint8 ContainerSlotA = 0;
    };

    class PlayerCliSwapInvItem
    {
        InvUpdate Inv;
        uint8 Slot2 = 0;
        uint8 Slot1 = 0;
    };

    class PlayerCliSplitItem
    {
        uint8 ToSlot = 0;
        uint8 ToPackSlot = 0;
        uint8 FromPackSlot = 0;
        int32 Quantity = 0;
        InvUpdate Inv;
        uint8 FromSlot = 0;
    };

    class PlayerCliAutoEquipItemSlot
    {
        ObjectGuid Item;
        uint8 ItemDstSlot = 0;
        InvUpdate Inv;
    };

    class PlayerMoveStartForward
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartBackward
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStop
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartStrafeLeft
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartStrafeRight
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStopStrafe
    {
        CliMovementStatus Status;
    };

    class PlayerMoveJump
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartTurnLeft
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartTurnRight
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStopTurn
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartPitchUp
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartPitchDown
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStopPitch
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetRunMode
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetWalkMode
    {
        CliMovementStatus Status;
    };

    class PlayerMoveTeleportCheat
    {
        float Facing = 0.0f;
        Vector3 Position;
    };

    class PlayerMoveCharmTeleportCheat
    {
        float Facing = 0.0f;
        Vector3 Position;
    };

    class PlayerMoveSetRelativePosition
    {
        Vector3 Position;
        float Facing = 0.0f;
    };

    class PlayerMoveTeleportAck
    {
        ObjectGuid MoverGUID;
        uint32 AckIndex = 0;
        uint32 MoveTime = 0;
    };

    class PlayerMoveFallLand
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartSwim
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStopSwim
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetRunSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetRunBackSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetWalkSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetSwimSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetSwimBackSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetAllSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetTurnRateCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveToggleCollisionCheat
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetFacing
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetPitch
    {
        CliMovementStatus Status;
    };

    class PlayerMoveForceRunSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveForceRunBackSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveForceSwimSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveForceRootAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveForceUnrootAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveHeartbeat
    {
        CliMovementStatus Status;
    };

    class PlayerMoveEmbeddedHeartbeat
    {
        CliMovementStatus Status;
    };

    class PlayerMoveKnockBackAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveHoverAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveSetVehicleRecIdAck
    {
        int32 VehicleRecID = 0;
        CliMovementAck Data;
    };

    class PlayerMoveApplyMovementForceAck
    {
        int32 TransportID = 0;
        Vector2 Direction;
        uint32 MovementForceID = 0;
        CliMovementAck Data;
    };

    class PlayerMoveRemoveMovementForceAck
    {
        CliMovementAck Data;
        uint32 MovementForceID = 0;
    };

    class PlayerMoveRemoveMovementForces
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSplineDone
    {
        uint32 SplineID = 0;
        CliMovementStatus Status;
    };

    class PlayerMoveFallReset
    {
        CliMovementStatus Status;
    };

    class PlayerMoveTimeSkipped
    {
        ObjectGuid MoverGUID;
        uint32 TimeSkipped = 0;
    };

    class PlayerMoveFeatherFallAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveWaterWalkAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveStartSwimCheat
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStopSwimCheat
    {
        CliMovementStatus Status;
    };

    class PlayerMoveForceWalkSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveForceSwimBackSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveForceTurnRateChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveEnableSwimToFlyTransAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveSetCanTurnWhileFallingAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveSetIgnoreMovementForcesAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveSetCanFlyAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveSetFly
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartAscend
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStopAscend
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetFlightSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveSetFlightBackSpeedCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveForceFlightSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveForceFlightBackSpeedChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveChangeTransport
    {
        CliMovementStatus Status;
    };

    class PlayerMoveStartDescend
    {
        CliMovementStatus Status;
    };

    class PlayerMoveSetPitchRateCheat
    {
        float Speed = 0.0f;
    };

    class PlayerMoveForcePitchRateChangeAck
    {
        CliMovementSpeedAck Data;
    };

    class PlayerMoveDismissVehicle
    {
        CliMovementStatus Status;
    };

    class PlayerMoveChangeVehicleSeats
    {
        ObjectGuid DstVehicle;
        CliMovementStatus Status;
        uint8 DstSeatIndex = 0;
    };

    class PlayerMoveGravityDisableAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveGravityEnableAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveCollisionDisableAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveCollisionEnableAck
    {
        CliMovementAck Data;
    };

    class PlayerMoveSetCollisionHeightAck
    {
        CliMovementAck Data;
        UpdateCollisionHeightReason Reason;
        uint32 MountDisplayID = 0;
        float Height = 0.0f;
    };

    class PlayerSetActiveMover
    {
        ObjectGuid ActiveMover;
    };

    class PlayerTimeSyncResponse
    {
        uint32 ClientTime = 0;
        uint32 SequenceIndex = 0;
    };

    class PlayerTimeSyncResponseFailed
    {
        uint32 SequenceIndex = 0;
    };

    class PlayerTimeSyncResponseDropped
    {
        uint32 SequenceIndexFirst = 0;
        uint32 SequenceIndexLast = 0;
    };

    class PlayerTimeAdjustmentResponse
    {
        uint32 SequenceIndex = 0;
        uint32 ClientTime = 0;
    };

    class PlayerDiscardedTimeSyncAcks
    {
        uint32 MaxSequenceIndex = 0;
    };

    class CliRideTicket
    {
        ObjectGuid RequesterGuid;
        uint32 Id = 0;
        uint32 Type = 0;
        time_t Time = time_t(0);
    };

    class CliMovementAck
    {
        CliMovementStatus Status;
        uint32 AckIndex = 0;
    };

    class CliMovementSpeedAck
    {
        CliMovementAck Ack;
        float Speed = 0.0f;
    };

    class CliCUFProfile
    {
        std::string Name;
        uint16 FrameHeight = 0;
        uint16 FrameWidth = 0;
        uint8 SortBy = 0;
        uint8 HealthText = 0;
        bool KeepGroupsTogether = false;
        bool DisplayPets = false;
        bool DisplayMainTankAndAssist = false;
        bool DisplayHealPrediction = false;
        bool DisplayAggroHighlight = false;
        bool DisplayOnlyDispellableDebuffs = false;
        bool DisplayPowerBar = false;
        bool DisplayBorder = false;
        bool UseClassColors = false;
        bool HorizontalGroups = false;
        bool DisplayNonBossDebuffs = false;
        bool DynamicPosition = false;
        uint8 TopPoint = 0;
        uint8 BottomPoint = 0;
        uint8 LeftPoint = 0;
        uint16 TopOffset = 0;
        uint16 BottomOffset = 0;
        uint16 LeftOffset = 0;
        bool Locked = false;
        bool Shown = false;
        bool AutoActivate2Players = false;
        bool AutoActivate3Players = false;
        bool AutoActivate5Players = false;
        bool AutoActivate10Players = false;
        bool AutoActivate15Players = false;
        bool AutoActivate25Players = false;
        bool AutoActivate40Players = false;
        bool AutoActivateSpec1 = false;
        bool AutoActivateSpec2 = false;
        bool AutoActivatePvP = false;
        bool AutoActivatePvE = false;
    };

    class CliRaidMarkerData
    {
        ObjectGuid TransportGUID;
        int32 MapID = 0;
        Vector3 Position;
    };

    class CliSceneObjectEvent
    {
        std::string EventScript;
    };

    class LootRequest
    {
        ObjectGuid Object;
        uint8 LootListID = 0;
    };

    class CliSupportTicketHeader
    {
        int32 MapID = 0;
        Vector3 Position;
        float Facing = 0.0f;
    };

    class CliSupportTicketChatLine
    {
        time_t Timestamp = time_t(0);
        std::string Text;
    };

    class CliSupportTicketChatLog
    {
        std::vector<CliSupportTicketChatLine> Lines;
        Optional<uint32> ReportLineIndex;
    };

    class EarnedAchievement
    {
        int32 Id = 0;
        Data Date;
        ObjectGuid Owner;
        uint32 VirtualRealmAddress = 0;
        uint32 NativeRealmAddress = 0;
    };

    class CliPlaySceneData
    {
        ObjectGuid TransportGUID;
        int32 SceneID = 0;
        uint32 PlaybackFlags = 0;
        uint32 SceneInstanceID = 0;
        int32 SceneScriptPackageID = 0;
        Vector3 Pos;
        float Facing = 0.0f;
    };

    class CriteriaProgress
    {
        int32 Id = 0;
        uint64 Quantity = 0;
        ObjectGuid Player;
        int32 Flags = 0;
        Data Date;
        time_t TimeFromStart = time_t(0);
        time_t TimeFromCreate = time_t(0);
    };

    class ElaspedTimer
    {
        uint32 TimerID = 0;
        time_t CurrentDuration = time_t(0);
    };

    class ImmigrantHostSearchLog
    {
        ObjectGuid PartyMember;
        bool IsLeader = false;
        uint32 Realm = 0;
        uint32 ImmigrantPop = 0;
        ImmigrationState State;
    };

    class CliClientSettings
    {
        float FarClip = 0.0f;
    };

    class ChatMsg
    {
        uint8 SlashCmd = 0;
        int8 Language = 0;
        ObjectGuid SenderGUID;
        ObjectGuid SenderGuildGUID;
        ObjectGuid TargetGUID;
        ObjectGuid PartyGUID;
        uint32 SenderVirtualAddress = 0;
        uint32 TargetVirtualAddress = 0;
        std::string SenderName;
        std::string TargetName;
        std::string Prefix;
        std::string Channel;
        std::string ChatText;
        int32 AchievementID = 0;
        uint16 ChatFlags = 0;
        float DisplayTime = 0.0f;
        bool HideChatLog = false;
        bool FakeSenderName = false;
    };

    class UserClientComplaintOffender
    {
        ObjectGuid PlayerGuid;
        uint32 RealmAddress = 0;
        uint32 TimeSinceOffence = 0;
    };

    class UserClientComplaintChat
    {
        uint32 Command = 0;
        uint32 ChannelID = 0;
        std::string MessageLog;
    };

    class ClientCalendarAddEventInviteInfo
    {
        ObjectGuid Guid;
        uint8 Status = 0;
        uint8 Moderator = 0;
    };

    class ClientCalendarAddEventInfo
    {
        std::string Title;
        std::string Description;
        uint8 EventType = 0;
        int32 TextureID = 0;
        uint32 Time = 0;
        uint32 Flags = 0;
        std::vector<ClientCalendarAddEventInviteInfo> Invites;
    };

    class PetRenameData
    {
        int32 PetNumber = 0;
        std::string NewName;
        bool HasDeclinedNames = false;
        std::string DeclinedNames[5] = { };
    };

    class TalentGroupInfo
    {
        int32 SpecID = 0;
        std::vector<uint16> TalentIDs;
        uint16 GlyphIDs[6] = { };
    };

    class TalentInfoUpdate
    {
        uint8 ActiveGroup = 0;
        std::vector<TalentGroupInfo> TalentGroups;
    };

    class ClientGossipOptions
    {
        int32 ClientOption = 0;
        uint8 OptionNPC = 0;
        int8 OptionFlags = 0;
        int32 OptionCost = 0;
        std::string Text;
        std::string Confirm;
    };

    class EquipmentSetData
    {
        ObjectGuid Guid;
        uint32 SetID = 0;
        std::string SetName;
        std::string SetIcon;
        ObjectGuid Pieces[19] = { };
    };

    class QuestChoiceItem
    {
        int32 ItemID = 0;
        int32 Quantity = 0;
    };

    class QuestRewards
    {
        int32 ChoiceItemCount = 0;
        int32 ItemCount = 0;
        int32 Money = 0;
        int32 Xp = 0;
        int32 Title = 0;
        int32 Talents = 0;
        int32 FactionFlags = 0;
        int32 SpellCompletionDisplayID = 0;
        int32 SpellCompletionID = 0;
        int32 SkillLineID = 0;
        int32 NumSkillUps = 0;
        QuestChoiceItem ChoiceItems[6] = { };
        int32 ItemID[4] = { };
        int32 ItemQty[4] = { };
        int32 FactionID[5] = { };
        int32 FactionValue[5] = { };
        int32 FactionOverride[5] = { };
        int32 CurrencyID[4] = { };
        int32 CurrencyQty[4] = { };
    };

    class QuestDescEmote
    {
        int32 Type = 0;
        uint32 Delay = 0;
    };

    class CliCreatureStats
    {
        Dynamicstd::string Title;
        Dynamicstd::string TitleAlt;
        Dynamicstd::string CursorName;
        int32 CreatureType = 0;
        int32 CreatureFamily = 0;
        int32 Classification = 0;
        float HpMulti = 0.0f;
        float EnergyMulti = 0.0f;
        bool Leader = false;
        std::vector<int32> QuestItems;
        int32 CreatureMovementInfoID = 0;
        int32 RequiredExpansion = 0;
        int32 Flags[2] = { };
        int32 ProxyCreatureID[2] = { };
        int32 CreatureDisplayID[4] = { };
        Dynamicstd::string Name[4] = { };
        Dynamicstd::string NameAlt[4] = { };
    };

    class QuestObjectiveCollect
    {
        int32 ObjectID = 0;
        int32 Amount = 0;
    };

    class QuestCurrency
    {
        int32 CurrencyID = 0;
        int32 Amount = 0;
    };

    class QuestGiverRequestItems
    {
        ObjectGuid QuestGiverGUID;
        int32 QuestGiverCreatureID = 0;
        int32 QuestID = 0;
        int32 CompEmoteDelay = 0;
        int32 CompEmoteType = 0;
        bool AutoLaunched = false;
        int32 SuggestPartyMembers = 0;
        int32 MoneyToGet = 0;
        std::vector<QuestObjectiveCollect> QuestObjectiveCollect;
        std::vector<QuestCurrency> QuestCurrency;
        int32 StatusFlags = 0;
        int32 QuestFlags[2] = { };
    };

    class QuestGiverOfferReward
    {
        ObjectGuid QuestGiverGUID;
        int32 QuestGiverCreatureID = 0;
        int32 QuestID = 0;
        bool AutoLaunched = false;
        int32 SuggestedPartyMembers = 0;
        QuestRewards QuestRewards;
        std::vector<QuestDescEmote> Emotes;
        int32 QuestFlags[2] = { };
    };

    class DeclinedBattlePetNames
    {
        std::string Name[5] = { };
    };

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

    class QuestPOIBlobData
    {
        int32 BlobIndex = 0;
        int32 ObjectiveIndex = 0;
        int32 QuestObjectiveID = 0;
        int32 QuestObjectID = 0;
        int32 MapID = 0;
        int32 WorldMapAreaID = 0;
        int32 Floor = 0;
        int32 Priority = 0;
        int32 Flags = 0;
        int32 WorldEffectID = 0;
        int32 PlayerConditionID = 0;
        int32 NumPoints = 0;
        std::vector<QuestPOIBlobPoint> Points;
    };

    class QuestPOIData
    {
        int32 QuestID = 0;
        int32 NumBlobs = 0;
        std::vector<QuestPOIBlobData> Blobs;
    };

    class LfgBootInfo
    {
        bool VoteInProgress = false;
        bool VotePassed = false;
        bool MyVoteCompleted = false;
        bool MyVote = false;
        ObjectGuid Target;
        uint32 TotalVotes = 0;
        uint32 BootVotes = 0;
        int32 TimeLeft = 0;
        uint32 VotesNeeded = 0;
        std::string Reason;
    };

    class LFGBlackListSlot
    {
        uint32 Slot = 0;
        uint32 Reason = 0;
        int32 SubReason1 = 0;
        int32 SubReason2 = 0;
    };

    class LFGBlackList
    {
        Optional<ObjectGuid> PlayerGuid;
        std::vector<LFGBlackListSlot> Slot;
    };

    class LfgPlayerQuestRewardItem
    {
        int32 ItemID = 0;
        int32 Quantity = 0;
    };

    class LfgPlayerQuestRewardCurrency
    {
        int32 CurrencyID = 0;
        int32 Quantity = 0;
    };

    class LfgPlayerQuestReward
    {
        uint32 Mask = 0;
        int32 RewardMoney = 0;
        int32 RewardXP = 0;
        std::vector<LfgPlayerQuestRewardItem> Item;
        std::vector<LfgPlayerQuestRewardCurrency> Currency;
        std::vector<LfgPlayerQuestRewardCurrency> BonusCurrency;
    };

    class LfgPlayerDungeonInfo
    {
        uint32 Slot = 0;
        bool FirstReward = false;
        int32 CompletionQuantity = 0;
        int32 CompletionLimit = 0;
        int32 CompletionCurrencyID = 0;
        int32 SpecificQuantity = 0;
        int32 SpecificLimit = 0;
        int32 OverallQuantity = 0;
        int32 OverallLimit = 0;
        int32 PurseWeeklyQuantity = 0;
        int32 PurseWeeklyLimit = 0;
        int32 PurseQuantity = 0;
        int32 PurseLimit = 0;
        int32 Quantity = 0;
        uint32 CompletedMask = 0;
        bool int16ageEligible = false;
        std::vector<LfgPlayerQuestReward> int16ageReward;
        LfgPlayerQuestReward Rewards;
    };

    class LFGPlayerRewards
    {
        int32 RewardItem = 0;
        uint32 RewardItemQuantity = 0;
        int32 BonusCurrency = 0;
        bool IsCurrency = false;
    };

    class LFGListJoinRequest
    {
        uint32 ActivityID = 0;
        uint32 RequiredItemLevel = 0;
        std::string Name;
        std::string Comment;
        std::string VoiceChat;
    };

    class LFGListBlacklistEntry
    {
        uint32 ActivityID = 0;
        uint32 Reason = 0;
    };

    class LFGListBlacklist
    {
        std::vector<LFGListBlacklistEntry> Entries;
    };

    class GMTicketCase
    {
        int32 CaseID = 0;
        time_t CaseOpened = time_t(0);
        int32 CaseStatus = 0;
        std::string Url;
        uint32 CfgRealmID = 0;
        ObjectGuid CharacterID;
        std::string WaitTimeOverrideMessage;
        int32 WaitTimeOverrideMinutes = 0;
    };

    class CliAccountCharacterData
    {
        uint32 WowAccountID = 0;
        uint32 VirtualRealmAddress = 0;
        ObjectGuid Guid;
        std::string Name;
        std::string RealmName;
        uint8 RaceID = 0;
        uint8 ClassID = 0;
        uint8 SexID = 0;
        uint8 ExperienceLevel = 0;
    };

    class NotifyDestLocSpellCastData
    {
        ObjectGuid Caster;
        ObjectGuid DestTransport;
        int32 SpellID = 0;
        Vector3 SourceLoc;
        Vector3 DestLoc;
        float MissileTrajectoryPitch = 0.0f;
        float MissileTrajectorySpeed = 0.0f;
        uint32 TravelTime = 0;
        uint8 DestLocSpellCastIndex = 0;
        uint8 CastID = 0;
    };

    class SkillLineData
    {
        int32 SpellID = 0;
        std::vector<int32> SkillLineIDs;
        std::vector<int32> SkillRanks;
        std::vector<int32> SkillMaxRanks;
        std::vector<int32> KnownAbilitySpellIDs;
    };

    class PVPBracketData
    {
        int32 Rating = 0;
        int32 Rank = 0;
        int32 WeeklyPlayed = 0;
        int32 WeeklyWon = 0;
        int32 SeasonPlayed = 0;
        int32 SeasonWon = 0;
        int32 WeeklyBestRating = 0;
        uint8 Bracket = 0;
    };

    class GarrisonPlotInfo
    {
        int32 GarrPlotInstanceID = 0;
        Vector3 PlotPos;
        int32 PlotType = 0;
    };

    class GarrisonBuildingInfo
    {
        int32 GarrPlotInstanceID = 0;
        int32 GarrBuildingID = 0;
        time_t TimeBuilt = time_t(0);
        bool Active = false;
        Vector3 BuildingPos;
        float BuildingFacing = 0.0f;
        int32 CurrentGarSpecID = 0;
    };

    class GarrisonRemoteBuildingInfo
    {
        int32 GarrPlotInstanceID = 0;
        int32 GarrBuildingID = 0;
    };

    class CliGarrisonRemoteSiteInfo
    {
        int32 GarrSiteLevelID = 0;
        std::vector<GarrisonRemoteBuildingInfo> Buildings;
    };

    class CliGarrisonRemoteInfo
    {
        std::vector<CliGarrisonRemoteSiteInfo> Sites;
    };

    class CliCharacterShipment
    {
        int32 ShipmentRecID = 0;
        uint64 ShipmentID = 0;
        time_t CreationTime = time_t(0);
        time_t ShipmentDuration = time_t(0);
    };

    class CharFactionChangeDisplayInfo
    {
        std::string Name;
        uint8 SexID = 0;
        uint8 SkinID = 0;
        uint8 HairColorID = 0;
        uint8 HairStyleID = 0;
        uint8 FacialHairStyleID = 0;
        uint8 FaceID = 0;
        uint8 RaceID = 0;
    };

    class ItemContext
    {
        uint8 Context = 0;
    };

    class ItemBonuses
    {
        std::vector<int32> BonusListIDs;
    };

    class ItemBonusInstanceData
    {
        ItemContext Context;
        ItemBonuses Bonuses;
    };

    class ItemInstance
    {
        int32 ItemID = 0;
        int32 RandomPropertiesSeed = 0;
        int32 RandomPropertiesID = 0;
        Optional<ItemBonusInstanceData> ItemBonus;
        Optional<CompactArray<int32> Modifications;
    };

    class PlayerGuidLookupHint
    {
        Optional<uint32> VirtualRealmAddress;
        Optional<uint32> NativeRealmAddress;
    };

    class CliMailAttachedItemEnchant
    {
        int32 Enchant = 0;
        uint32 Duration = 0;
        int32 Charges = 0;
    };

    class CliMailAttachedItem
    {
        uint8 Position = 0;
        int32 AttachID = 0;
        ItemInstance Item;
        int32 Count = 0;
        int32 Charges = 0;
        uint32 MaxDurability = 0;
        int32 Durability = 0;
        bool Unlocked = false;
        CliMailAttachedItemEnchant Enchants[8] = { };
    };

    class CliMailListEntry
    {
        int32 MailID = 0;
        uint8 SenderType = 0;
        Optional<ObjectGuid> SenderCharacter;
        PlayerGuidLookupHint SenderHint = 0;
        Optional<int32> AltSenderID;
        uint64 Cod = 0;
        int32 PackageID = 0;
        int32 StationeryID = 0;
        uint64 SentMoney = 0;
        int32 Flags = 0;
        float DaysLeft = 0.0f;
        int32 MailTemplateID = 0;
        std::string Subject;
        std::string Body;
        std::vector<CliMailAttachedItem> Attachments;
    };

    class CliMailNextTimeEntry
    {
        ObjectGuid SenderGUID;
        PlayerGuidLookupHint SenderHint = 0;
        float TimeLeft = 0.0f;
        int32 AltSenderID = 0;
        uint8 AltSenderType = 0;
        int32 StationeryID = 0;
    };

    class CliAuctionItemEnchant
    {
        int32 ID = 0;
        uint32 Expiration = 0;
        int32 Charges = 0;
        uint8 Slot = 0;
    };

    class CliAuctionItem
    {
        ItemInstance Item;
        int32 Count = 0;
        int32 Charges = 0;
        std::vector<CliAuctionItemEnchant> Enchantments;
        int32 Flags = 0;
        int32 AuctionItemID = 0;
        ObjectGuid Owner;
        uint64 MinBid = 0;
        uint64 MinIncrement = 0;
        uint64 BuyoutPrice = 0;
        int32 DurationLeft = 0;
        uint8 DeleteReason = 0;
        bool CensorServerSideInfo = false;
        bool CensorBidInfo = false;
        ObjectGuid ItemGUID;
        uint32 OwnerAccountID = 0;
        uint32 EndTime = 0;
        ObjectGuid Bidder;
        uint64 BidAmount = 0;
    };

    class CliVendorItem
    {
        uint32 Muid = 0;
        int32 Type = 0;
        ItemInstance Item;
        int32 Quantity = 0;
        int32 Price = 0;
        int32 Durability = 0;
        int32 StackCount = 0;
        int32 ExtendedCostID = 0;
        int32 PlayerConditionFailed = 0;
        bool DoNotFilterOnVendor = false;
    };

    class BonusObjectiveData
    {
        int32 BonusObjectiveID = 0;
        bool ObjectiveComplete = false;
    };

    class UserClientConnectToFailed
    {
        uint32 Serial = 0;
        int8 Con = 0;
    };

    class UserClientCreateGuildCheat
    {
        std::string GuildName;
    };

    class UserClientSetRole
    {
        ObjectGuid ChangedUnit;
        uint32 Role = 0;
        uint8 PartyIndex = 0;
    };

    class UserClientInitiateRolePoll
    {
        uint8 PartyIndex = 0;
    };

    class UserClientStartBattlegroundCheat
    {
        int32 MapID = 0;
        bool Rated = false;
    };

    class UserClientBFMgrEntryInviteResponse
    {
        uint64 QueueID = 0;
        bool AcceptedInvite = false;
    };

    class UserClientBFMgrQueueInviteResponse
    {
        uint64 QueueID = 0;
        bool AcceptedInvite = false;
    };

    class UserClientBFMgrQueueExitRequest
    {
        uint64 QueueID = 0;
    };

    class UserClientChangeGdfPVPRating
    {
        float Variance = 0.0f;
        float Rating = 0.0f;
        int32 Bracket = 0;
    };

    class UserClientStartWarGame
    {
        ObjectGuid OpposingPartyMember;
        uint64 QueueID = 0;
        bool TournamentRules = false;
        uint32 OpposingPartyMemberVirtualRealmAddress = 0;
        uint32 OpposingPartyMemberCfgRealmID = 0;
    };

    class UserClientStartSpectatorWarGame
    {
        uint32 OpposingPartyMemberCfgRealmID1 = 0;
        ObjectGuid OpposingPartyMember1;
        uint32 OpposingPartyMemberVirtualRealmAddress1 = 0;
        uint64 QueueID = 0;
        uint32 OpposingPartyMemberCfgRealmID2 = 0;
        uint32 OpposingPartyMemberVirtualRealmAddress2 = 0;
        ObjectGuid OpposingPartyMember2;
        bool TournamentRules = false;
    };

    class UserClientAcceptWargameInvite
    {
        ObjectGuid OpposingPartyMember;
        uint64 QueueID = 0;
        bool Accept = false;
    };

    class UserClientWorldTeleport
    {
        ObjectGuid Transport;
        float Facing = 0.0f;
        uint32 MapID = 0;
        Vector3 Position;
    };

    class UserClientForceTakeLeader
    {
        uint8 PartyIndex = 0;
    };

    class UserClientDBQuery
    {
        ObjectGuid Guid;
        uint32 TableHash = 0;
        int32 RecordID = 0;
    };

    class DBQuery
    {
        ObjectGuid Guid;
        int32 RecordID = 0;
    };

    class UserClientDBQueryBulk
    {
        uint32 TableHash = 0;
        std::vector<DBQuery> Queries;
    };

    class UserClientGenerateRandomCharacterName
    {
        uint8 Sex = 0;
        uint8 Race = 0;
    };

    class UserClientReorderEntry
    {
        ObjectGuid PlayerGUID;
        uint8 NewPosition = 0;
    };

    class UserClientReorderCharacters
    {
        std::vector<UserClientReorderEntry> Entries;
    };

    class UserClientPlayerLogin
    {
        CliClientSettings ClientSettings;
        ObjectGuid PlayerGUID;
    };

    class UserClientCheatPlayerLogin
    {
        ObjectGuid PlayerGUID;
        CliClientSettings ClientSettings;
    };

    class UserClientWardenData
    {
        Data Packet;
    };

    class UserClientUndeleteGuildCheat
    {
        std::string BackupGuildName;
    };

    class UserClientCommentatorStartWargame
    {
        uint64 QueueID = 0;
        std::string Names[2] = { };
    };

    class UserClientCommentatorEnable
    {
        int32 Enable = 0;
    };

    class UserClientCommentatorGetMapInfo
    {
        std::string PlayerName;
    };

    class UserClientCommentatorGetPlayerInfo
    {
        ServerSpec WorldServer;
        uint32 MapID = 0;
    };

    class UserClientCommentatorEnterInstance
    {
        uint64 InstanceID = 0;
        uint32 MapID = 0;
        int32 DifficultyID = 0;
        ServerSpec WorldServer;
    };

    class UserClientRequestPartyJoinUpdates
    {
        uint8 PartyIndex = 0;
    };

    class UserClientLoadingScreenNotify
    {
        int32 MapID = 0;
        bool Showing = false;
    };

    class CliStructMailAttachment
    {
        ObjectGuid ItemGUID;
        uint8 AttachPosition = 0;
    };

    class CliStructSendMail
    {
        ObjectGuid Mailbox;
        std::string Target;
        std::string Subject;
        std::string Body;
        int32 StationeryID = 0;
        int32 PackageID = 0;
        std::vector<CliStructMailAttachment> Attachments;
        uint64 SendMoney = 0;
        uint64 Cod = 0;
    };

    class UserClientSendMail
    {
        CliStructSendMail Info;
    };

    class UserClientGuildResetChallenge
    {
        int32 ChallengeType = 0;
    };

    class UserClientGMSSHijackCheat
    {
        ObjectGuid Player;
    };

    class UserClientSetMoneyCheat
    {
        std::string Target;
        uint64 Amount = 0;
    };

    class UserClientPartyInvite
    {
        ObjectGuid TargetGuid;
        uint32 ProposedRoles = 0;
        std::string TargetName;
        uint8 PartyIndex = 0;
        std::string TargetRealm;
        uint32 TargetCfgRealmID = 0;
    };

    class UserClientPartyInviteResponse
    {
        uint8 PartyIndex = 0;
        bool Accept = false;
        Optional<uint32> RolesDesired;
    };

    class UserClientSetCurrencyCheat
    {
        ObjectGuid TargetGUID;
        int32 Type = 0;
        int32 Quantity = 0;
        int8 IsDelta = 0;
        int8 Column = 0;
    };

    class UserClientSimulateTickets
    {
        uint32 Seed = 0;
        uint32 Count = 0;
        uint32 RideType = 0;
    };

    class UserClientGuildInviteByName
    {
        std::string Name;
    };

    class UserClientDFProposalResponse
    {
        uint32 ProposalID = 0;
        CliRideTicket Ticket;
        bool Accepted = false;
        uint64 InstanceID = 0;
    };

    class UserClientDFJoin
    {
        bool QueueAsGroup = false;
        uint32 Roles = 0;
        uint8 PartyIndex = 0;
        std::string Comment;
        std::vector<uint32> Slots;
        uint32 Needs[3] = { };
    };

    class UserClientLFGListJoin
    {
        LFGListJoinRequest Info;
    };

    class UserClientLFGListUpdateRequest
    {
        LFGListJoinRequest Info;
        CliRideTicket Ticket;
    };

    class UserClientLFGListLeave
    {
        CliRideTicket Ticket;
    };

    class UserClientDFLeave
    {
        CliRideTicket Ticket;
    };

    class UserClientDFSearchJoin
    {
        uint32 Slot = 0;
    };

    class UserClientDFSearchLeave
    {
        uint32 Slot = 0;
    };

    class UserClientDFGetSystemInfo
    {
        uint8 PartyIndex = 0;
        bool Player = false;
    };

    class UserClientDFSetComment
    {
        CliRideTicket Ticket;
        std::string Comment;
    };

    class UserClientDFSetRoles
    {
        uint32 RolesDesired = 0;
        uint8 PartyIndex = 0;
    };

    class UserClientDFSetNeeds
    {
        bool Delta = false;
        CliRideTicket Ticket;
        uint32 Needs[3] = { };
    };

    class UserClientDFBootPlayerVote
    {
        bool Vote = false;
    };

    class UserClientDFTeleport
    {
        bool TeleportOut = false;
    };

    class UserClientSetEveryoneIsAssistant
    {
        uint8 PartyIndex = 0;
        bool EveryoneIsAssistant = false;
    };

    class UserClientBFMgrAdvanceState
    {
        int32 QueueID = 0;
    };

    class UserClientBattlefieldSetNextTransitionTime
    {
        int32 SecondsUntilTransition = 0;
        int32 QueueID = 0;
    };

    class UserClientGuildFlush
    {
        ObjectGuid GuildGUID;
    };

    class UserClientLFGuildAddRecruit
    {
        ObjectGuid GuildGUID;
        int32 Availability = 0;
        int32 ClassRoles = 0;
        int32 PlayStyle = 0;
        std::string Comment;
    };

    class UserClientLFGuildSetGuildPost
    {
        std::string Comment;
        int32 Availability = 0;
        bool Active = false;
        int32 PlayStyle = 0;
        int32 ClassRoles = 0;
        int32 LevelRange = 0;
    };

    class UserClientLFGuildBrowse
    {
        int32 CharacterLevel = 0;
        int32 Availability = 0;
        int32 ClassRoles = 0;
        int32 PlayStyle = 0;
    };

    class UserClientSetDFFastLaunch
    {
        bool Set = false;
    };

    class UserClientSetTimeWalkerDungeon
    {
        int32 LfgDungeonID = 0;
    };

    class UserClientSendSoRRequestViaAddress
    {
        std::string Text;
        std::string Email;
    };

    class UserClientSendSoRRequestViaBnetAccountID
    {
        std::string Text;
        uint32 BnetAccountID = 0;
    };

    class UserClientBattlePetDeletePet
    {
        ObjectGuid BattlePetGUID;
    };

    class UserClientBattlePetDeletePetCheat
    {
        ObjectGuid BattlePetGUID;
    };

    class UserClientBattlePetModifyName
    {
        std::string Name;
        Optional<DeclinedBattlePetNames> DeclinedNames;
        ObjectGuid BattlePetGUID;
    };

    class UserClientBattlePetSummon
    {
        ObjectGuid BattlePetGUID;
    };

    class UserClientBattlePetSetLevel
    {
        std::vector<ObjectGuid> BattlePetGUIDs;
        uint16 Level = 0;
    };

    class UserClientRestoreBattlePetsHealth
    {
        int8 HealthPct = 0;
    };

    class UserClientBattlePetSetBattleSlot
    {
        ObjectGuid BattlePetGUID;
        uint8 SlotIndex = 0;
    };

    class UserClientBattlePetSetCollar
    {
        int32 CollarItemID = 0;
        uint8 SlotIndex = 0;
    };

    class UserClientAddBattlePet
    {
        bool AllSpecies = false;
        int32 SpeciesID = 0;
        int32 CreatureID = 0;
        bool IgnoreMaxPetRestriction = false;
    };

    class UserClientBattlePetSetFlags
    {
        ObjectGuid BattlePetGUID;
        uint32 Flags = 0;
        clibattlepetsetflagcontroltype ControlType;
    };

    class UserClientCheatBattlePetSetQuality
    {
        uint16 BreedQuality = 0;
        ObjectGuid BattlePetGUID;
        bool AllPetsInJournal = false;
    };

    class UserClientMountSetFavorite
    {
        int32 MountSpellID = 0;
        bool IsFavorite = false;
    };

    class UserClientDoReadyCheck
    {
        uint8 PartyIndex = 0;
    };

    class UserClientReadyCheckResponse
    {
        uint8 PartyIndex = 0;
        ObjectGuid PartyGUID;
        bool IsReady = false;
    };

    class UserClientSetActionButton
    {
        uint64 Action = 0;
        uint8 Index = 0;
    };

    class UserClientClearQuest
    {
        std::string Target;
        uint32 QuestID = 0;
    };

    class UserClientClearQuestLog
    {
        std::string Target;
        uint32 QuestID = 0;
    };

    class UserClientFlagQuest
    {
        std::string Target;
        uint32 QuestID = 0;
    };

    class UserClientFinishQuest
    {
        uint32 QuestID = 0;
        std::string Target;
    };

    class UserClientAdvanceQuest
    {
        std::string Target;
        uint32 QuestID = 0;
    };

    class UserClientTaxiEnable
    {
        std::string Target;
        uint32 NodeID = 0;
    };

    class UserClientTaxiClear
    {
        uint32 NodeID = 0;
        std::string Target;
    };

    class UserClientClearExplore
    {
        std::string Target;
        uint32 AreaID = 0;
    };

    class UserClientPetBattleInputFirstPet
    {
        int8 FrontPet = 0;
    };

    class UserClientPetBattleInput
    {
        PetBattleInput MsgData;
    };

    class UserClientPetBattleReplaceFrontPet
    {
        int8 FrontPet = 0;
    };

    class UserClientPetBeastMasterCheat
    {
        int32 Action = 0;
        std::string Name;
    };

    class UserClientCreateCharacter
    {
        uint8 FacialHairStyleID = 0;
        uint8 FaceID = 0;
        uint8 SexID = 0;
        uint8 HairStyleID = 0;
        uint8 SkinID = 0;
        uint8 RaceID = 0;
        uint8 ClassID = 0;
        uint8 OutfitID = 0;
        uint8 HairColorID = 0;
        Optional<int32> TemplateSetID;
        std::string Name;
    };

    class CliSupportTicketMailInfo
    {
        int32 MailID = 0;
        std::string MailBody;
        std::string MailSubject;
    };

    class CliSupportTicketCalendarEventInfo
    {
        uint64 EventID = 0;
        uint64 InviteID = 0;
        std::string EventTitle;
    };

    class CliSupportTicketPetInfo
    {
        ObjectGuid PetID;
        std::string PetName;
    };

    class CliSupportTicketGuildInfo
    {
        std::string GuildName;
        ObjectGuid GuildID;
    };

    class UserClientSupportTicketSubmitComplaint
    {
        CliSupportTicketChatLog ChatLog;
        std::string Note;
        Optional<CliSupportTicketGuildInfo> GuildInfo;
        Optional<CliSupportTicketMailInfo> MailInfo;
        ObjectGuid TargetCharacterGUID;
        Optional<CliSupportTicketPetInfo> PetInfo;
        Optional<CliSupportTicketCalendarEventInfo> CalendarInfo;
        CliComplaintType ComplaintType;
        CliSupportTicketHeader Header;
    };

    class UserClientSupportTicketSubmitBug
    {
        std::string Note;
        CliSupportTicketHeader Header;
    };

    class UserClientSupportTicketSubmitSuggestion
    {
        CliSupportTicketHeader Header;
        std::string Note;
    };

    class UserClientPartyUninvite
    {
        std::string Reason;
        uint8 PartyIndex = 0;
        ObjectGuid TargetGuid;
    };

    class UserClientSetLootMethod
    {
        ObjectGuid Master;
        int32 Threshold = 0;
        uint8 Method = 0;
        uint8 PartyIndex = 0;
    };

    class UserClientLeaveGroup
    {
        uint8 PartyIndex = 0;
    };

    class UserClientSetPartyLeader
    {
        ObjectGuid Target;
        uint8 PartyIndex = 0;
    };

    class UserClientMinimapPing
    {
        Vector2 Position;
        uint8 PartyIndex = 0;
    };

    class UserClientChangeSubGroup
    {
        ObjectGuid Target;
        uint8 Subgroup = 0;
        uint8 PartyIndex = 0;
    };

    class UserClientSwapSubGroups
    {
        ObjectGuid Target1;
        ObjectGuid Target2;
        uint8 PartyIndex = 0;
    };

    class UserClientConvertRaid
    {
        bool Raid = false;
    };

    class UserClientSetAssistantLeader
    {
        bool Set = false;
        uint8 PartyIndex = 0;
        ObjectGuid Target;
    };

    class UserClientUpdateRaidTarget
    {
        ObjectGuid Target;
        uint8 PartyIndex = 0;
        uint8 Symbol = 0;
    };

    class UserClientSetPartyAssignment
    {
        uint8 PartyIndex = 0;
        ObjectGuid Target;
        uint8 Assignment = 0;
        bool Set = false;
    };

    class UserClientSilencePartyTalker
    {
        bool Silence = false;
        ObjectGuid Target;
        uint8 PartyIndex = 0;
    };

    class UserClientRequestPartyMemberStats
    {
        ObjectGuid Target;
        uint8 PartyIndex = 0;
    };

    class UserClientRandomRoll
    {
        int32 Min = 0;
        int32 Max = 0;
        uint8 PartyIndex = 0;
    };

    class UserClientSetActiveVoiceChannel
    {
        uint8 ChannelType = 0;
        std::string ChannelName;
    };

    class UserClientVoiceAddIgnore
    {
        std::string OffenderName;
    };

    class UserClientVoiceDelIgnore
    {
        QualifiedGUID Player;
    };

    class UserClientMailReturnToSender
    {
        ObjectGuid SenderGUID;
        int32 MailID = 0;
    };

    class UserClientQueryScenarioPOI
    {
        std::vector<int32> MissingScenarioPOITreeIDs;
    };

    class UserClientGMRequestPlayerInfo
    {
        std::string PlayerName;
    };

    class UserClientGMSummon
    {
        std::string PlayerName;
    };

    class UserClientGhost
    {
        bool Enable = false;
        std::string PlayerName;
    };

    class UserClientAddBattlenetFriend
    {
        uint32 RoleID = 0;
        bool VerifyOnly = false;
        ObjectGuid TargetGUID;
        uint64 ClientToken = 0;
        uint32 TargetVirtualRealmAddress = 0;
        std::string InvitationMsg;
    };

    class UserClientMoveCharacter
    {
        ObjectGuid CharacterGUID;
        int32 MapID = 0;
        Vector3 Position;
        float Facing = 0.0f;
    };

    class UserClientClearPaidService
    {
        ObjectGuid CharacterGUID;
    };

    class UserClientSetPromotionRequest
    {
        int32 PromotionID = 0;
    };

    class UserClientQueryCorpseTransport
    {
        ObjectGuid Transport;
    };

    class UserClientCanDuel
    {
        ObjectGuid TargetGUID;
    };

    class UserClientSetImmigrantHostSearchLog
    {
        bool Report = false;
    };

    class UserClientTeleportToUnit
    {
        std::string UnitName;
    };

    class UserClientSetRealmSelector
    {
        std::string RealmName;
    };

    class UserClientUpdateClientSettings
    {
        CliClientSettings Settings;
    };

    class UserClientSendRealmBroadcastMessage
    {
        std::string Text;
    };

    class UserClientSendWorldBroadcastMessage
    {
        std::string Text;
    };

    class UserClientGMUpdateTicketStatus
    {
        ObjectGuid TargetGUID;
        int32 TicketID = 0;
        int32 StatusInt = 0;
    };

    class UserClientGMCreateTicketResponse
    {
        ObjectGuid TargetGUID;
        std::string Arguments;
    };

    class UserClientSummonResponse
    {
        bool Accept = false;
        ObjectGuid SummonerGUID;
    };

    class UserClientGMChangePVPRating
    {
        int32 Season = 0;
        int32 Bracket = 0;
        int32 Rating = 0;
    };

    class UserClientComplaint
    {
        UserClientComplaintOffender Offender;
        uint8 ComplaintType = 0;
        ObjectGuid EventGuid;
        ObjectGuid InviteGuid;
        uint32 MailID = 0;
        UserClientComplaintChat Chat;
    };

    class UserClientGMShowComplaints
    {
        std::string Name;
    };

    class UserClientGMUnsquelch
    {
        std::string Name;
    };

    class UserClientCalendarGetEvent
    {
        uint64 EventID = 0;
    };

    class UserClientCalendarGuildFilter
    {
        uint8 MinLevel = 0;
        uint8 MaxLevel = 0;
        uint8 MaxRankOrder = 0;
    };

    class UserClientCalendarEventInvite
    {
        uint64 ModeratorID = 0;
        bool IsSignUp = false;
        bool Creating = false;
        uint64 EventID = 0;
        std::string Name;
    };

    class UserClientCalendarRemoveInvite
    {
        uint64 ModeratorID = 0;
        ObjectGuid Guid;
        uint64 EventID = 0;
        uint64 InviteID = 0;
    };

    class UserClientCalendarEventRSVP
    {
        uint64 InviteID = 0;
        uint64 EventID = 0;
        uint8 Status = 0;
    };

    class UserClientCalendarEventStatus
    {
        uint64 ModeratorID = 0;
        uint64 EventID = 0;
        uint64 InviteID = 0;
        ObjectGuid Guid;
        uint8 Status = 0;
    };

    class UserClientCalendarEventModeratorStatus
    {
        uint64 InviteID = 0;
        uint64 EventID = 0;
        ObjectGuid Guid;
        uint64 ModeratorID = 0;
        uint8 Status = 0;
    };

    class UserClientCalendarRemoveEvent
    {
        uint64 ModeratorID = 0;
        uint64 EventID = 0;
        uint32 Flags = 0;
    };

    class UserClientCalendarCopyEvent
    {
        uint64 ModeratorID = 0;
        uint64 EventID = 0;
        uint32 Date = 0;
    };

    class UserClientCalendarComplain
    {
        uint64 InviteID = 0;
        uint64 EventID = 0;
        ObjectGuid InvitedByGUID;
    };

    class UserClientCalendarEventSignUp
    {
        bool Tentative = false;
        uint64 EventID = 0;
    };

    class UserClientCalendarEventInviteNotes
    {
        uint64 EventID = 0;
        ObjectGuid Guid;
        uint64 InviteID = 0;
        uint64 ModeratorID = 0;
        std::string Notes;
    };

    class UserClientCalendarAddEvent
    {
        uint32 MaxSize = 0;
        ClientCalendarAddEventInfo EventInfo;
    };

    class ClientCalendarUpdateEventInfo
    {
        uint64 EventID = 0;
        uint64 ModeratorID = 0;
        std::string Title;
        std::string Description;
        uint8 EventType = 0;
        int32 TextureID = 0;
        uint32 Time = 0;
        uint32 Flags = 0;
    };

    class UserClientCalendarUpdateEvent
    {
        uint32 MaxSize = 0;
        ClientCalendarUpdateEventInfo EventInfo;
    };

    class UserClientWhoIs
    {
        std::string CharName;
    };

    class UserClientWho
    {
        WhoRequest Request;
        std::vector<int32> Areas;
    };

    class UserClientSetDungeonDifficulty
    {
        uint32 DifficultyID = 0;
    };

    class ClientGMSurveyQuestion
    {
        int32 QuestionID = 0;
        uint8 Answer = 0;
        std::string AnswerComment;
    };

    class UserClientGMSurveySubmit
    {
        std::vector<ClientGMSurveyQuestion> SurveyQuestion;
        int32 SurveyID = 0;
        std::string Comment;
    };

    class UserClientVoiceSessionEnable
    {
        bool EnableVoiceChat = false;
        bool EnableMicrophone = false;
    };

    class UserClientResurrectResponse
    {
        ObjectGuid Resurrecter;
        uint32 Response = 0;
    };

    class UserClientPetRename
    {
        PetRenameData RenameData;
    };

    class UserClientBugReport
    {
        ReportType Type;
        std::string Text;
        std::string DiagInfo;
    };

    class UserClientReferAFriendCheat
    {
        std::string Name;
    };

    class UserClientSetSavedInstanceExtend
    {
        int32 MapID = 0;
        bool Extend = false;
        uint32 DifficultyID = 0;
    };

    class UserClientSetPlayerDeclinedNames
    {
        ObjectGuid Player;
        std::string DeclinedName[5] = { };
    };

    class UserClientQueryPlayerName
    {
        ObjectGuid Player;
        PlayerGuidLookupHint Hint = 0;
    };

    class UserClientQueryRealmName
    {
        uint32 VirtualRealmAddress = 0;
    };

    class UserClientQueryGuildInfo
    {
        ObjectGuid PlayerGuid;
        ObjectGuid GuildGuid;
    };

    class UserClientCharCustomize
    {
        uint8 HairStyleID = 0;
        uint8 FaceID = 0;
        ObjectGuid CharGUID;
        uint8 SexID = 0;
        std::string CharName;
        uint8 HairColorID = 0;
        uint8 FacialHairStyleID = 0;
        uint8 SkinID = 0;
    };

    class UserClientServerInfoQuery
    {
        std::string Category;
    };

    class UserClientGMTicketCreate
    {
        Vector3 Pos;
        int32 MapID = 0;
        uint8 Flags = 0;
        bool NeedMoreHelp = false;
        bool NeedResponse = false;
        std::string Description;
        Data ChatHistoryData;
    };

    class UserClientGMTicketUpdateText
    {
        std::string Description;
    };

    class UserClientGMTicketAcknowledgeSurvey
    {
        int32 CaseID = 0;
    };

    class UserClientGMLagReport
    {
        int32 MapID = 0;
        int32 LagKind = 0;
        Vector3 Loc;
    };

    class UserClientGMDestroyCorpse
    {
        std::string Name;
    };

    class UserClientCharRaceOrFactionChange
    {
        Optional<uint8> HairColorID;
        uint8 RaceID = 0;
        uint8 SexID = 0;
        Optional<uint8> SkinID;
        Optional<uint8> FacialHairStyleID;
        ObjectGuid Guid;
        bool FactionChange = false;
        std::string Name;
        Optional<uint8> FaceID;
        Optional<uint8> HairStyleID;
    };

    class UserClientRequestAccountData
    {
        uint8 DataType = 0;
    };

    class UserClientUpdateAccountData
    {
        time_t Time = time_t(0);
        uint32 Size = 0;
        uint8 DataType = 0;
        Data CompressedData;
    };

    class UserClientSetPVPWeeklyGames
    {
        uint32 NumPlayed = 0;
        int32 Season = 0;
        uint32 NumWon = 0;
        uint8 Bracket = 0;
    };

    class UserClientSetPVPSeasonGames
    {
        uint32 NumWon = 0;
        int32 Season = 0;
        uint32 NumPlayed = 0;
        uint8 Bracket = 0;
    };

    class UserClientGMNukeCharacter
    {
        ObjectGuid Target;
    };

    class UserClientCharDelete
    {
        ObjectGuid Guid;
    };

    class UserClientCharForceDelete
    {
        ObjectGuid Guid;
    };

    class UserClientGMAccountOnline
    {
        uint32 AccountID = 0;
    };

    class UserClientGMGuildSave
    {
        std::string Name;
    };

    class UserClientLowLevelRaid
    {
        bool Enable = false;
    };

    class UserClientInspectPVP
    {
        ObjectGuid InspectTarget;
        uint32 InspectRealmAddress = 0;
    };

    class UserClientUnclaimLicense
    {
        int32 License = 0;
    };

    class UserClientGmSilence
    {
        int32 Action = 0;
        std::string Name;
    };

    class UserClientGmRevealTo
    {
        uint32 Type = 0;
        std::string Name;
    };

    class UserClientGmResurrect
    {
        std::string Name;
    };

    class UserClientCheatPlayerLookup
    {
        std::string Name;
    };

    class UserClientGmFreeze
    {
        std::string Name;
    };

    class UserClientGmCharacterRestore
    {
        std::vector<uint8> Data;
        uint32 Locale = 0;
        uint32 ClientToken = 0;
        uint32 ToAccount = 0;
        bool Compressed = false;
    };

    class UserClientGmCharacterSave
    {
        std::string CharacterName;
        uint32 Flags = 0;
    };

    class UserClientGMNukeAccount
    {
        uint32 AccountID = 0;
    };

    class UserClientBeastmaster
    {
        int32 Op = 0;
        std::string TargetName;
    };

    class UserClientProfileDataRequest
    {
        bool Run = false;
    };

    class UserClientOfferPetition
    {
        ObjectGuid TargetPlayer;
        ObjectGuid ItemGUID;
    };

    class UserClientQuestPOIQuery
    {
        int32 MissingQuestCount = 0;
        int32 MissingQuestPOIs[50] = { };
    };

    class UserClientGMInvis
    {
        int32 Action = 0;
        std::string PlayerName;
    };

    class UserClientGMBindOther
    {
        std::string PlayerName;
    };

    class UserClientGMShowLabel
    {
        int32 Op = 0;
        std::string TargetName;
    };

    class UserClientGmSetSecurityGroup
    {
        std::string Name;
        uint32 Group = 0;
    };

    class UserClientGmNuke
    {
        std::string Name;
    };

    class UserClientDanceStudioAddMove
    {
        uint64 ImageBase = 0;
        std::string PseudoFilename;
        uint64 Caller = 0;
        std::string Code;
    };

    class UserClientGetAccountCharacterList
    {
        uint32 Token = 0;
    };

    class UserClientLiveRegionGetAccountCharacterList
    {
        std::string DevRealmOverride;
        uint32 Token = 0;
        std::string DevCharOverride;
        Optional<uint8> RegionID;
    };

    class UserClientLiveRegionCharacterCopy
    {
        ObjectGuid Guid;
        uint32 VirtualRealmAddress = 0;
        uint32 Token = 0;
    };

    class UserClientLiveRegionAccountRestore
    {
        uint32 Token = 0;
        std::string DevRealmOverride;
        Optional<uint8> RegionID;
        std::string DevCharOverride;
    };

    class UserClientServerCommand
    {
        std::string Line;
        ObjectGuid Target;
    };

    class UserClientCharacterRenameRequest
    {
        std::string NewName;
        ObjectGuid Guid;
    };

    class UserClientShowTradeSkill
    {
        ObjectGuid PlayerGUID;
        int32 SkillLineID = 0;
        int32 SpellID = 0;
    };

    class UserClientBattlePayDistributionAssignToTarget
    {
        ObjectGuid TargetCharacter;
        uint64 DistributionID = 0;
        uint32 ProductChoice = 0;
        uint32 ClientToken = 0;
    };

    class UserClientBattlePayDistributionSelectChoice
    {
        uint64 DistributionID = 0;
        ObjectGuid TargetCharacter;
        uint32 ProductChoice = 0;
        uint32 ClientToken = 0;
    };

    class UserClientGuildSetGuildMaster
    {
        std::string NewMasterName;
    };

    class UserClientPetitionRenameGuild
    {
        ObjectGuid PetitionGuid;
        std::string NewGuildName;
    };

    class UserClientBattlePayStartPurchase
    {
        ObjectGuid TargetCharacter;
        uint32 ProductID = 0;
        uint32 ClientToken = 0;
    };

    class UserClientBattlePayConfirmPurchaseResponse
    {
        uint64 ClientCurrentPriceFixedPoint = 0;
        bool ConfirmPurchase = false;
        uint32 ServerToken = 0;
    };

    class UserClientBattlePayAckFailedResponse
    {
        uint32 ServerToken = 0;
    };

    class UserClientRecruitAFriend
    {
        std::string Email;
        std::string Text;
        std::string Name;
    };

    class UserClientAddAccountLicense
    {
        long BpayLicenseGroupID;
    };

    class UserClientSwitchCharacter
    {
        std::string CharacterName;
    };

    class UserClientSendContactList
    {
        uint32 Flags = 0;
    };

    class UserClientAddFriend
    {
        std::string Notes;
        std::string Name;
    };

    class UserClientDelFriend
    {
        QualifiedGUID Player;
    };

    class UserClientSetContactNotes
    {
        QualifiedGUID Player;
        std::string Notes;
    };

    class UserClientBattlenetChallengeResponse
    {
        BattlenetChallengeResult Result;
        uint32 Token = 0;
        std::string BattlenetError;
    };

    class UserClientAddIgnore
    {
        std::string Name;
    };

    class UserClientDelIgnore
    {
        QualifiedGUID Player;
    };

    class UserClientGMSetVeteranTrial
    {
        bool VeteranTrial = false;
    };

    class UserClientGMGrantAchievement
    {
        int32 AchievementID = 0;
        ObjectGuid Guid;
        std::string Target;
    };

    class UserClientGMRemoveAchievement
    {
        ObjectGuid Guid;
        std::string Target;
        int32 AchievementID = 0;
    };

    class UserClientGMSetCriteria
    {
        int32 CriteriaID = 0;
        std::string Target;
        int32 Quantity = 0;
        ObjectGuid Guid;
    };

    class UserClientGMCreateItemTarget
    {
        ItemContext CreationContext;
        int32 ItemID = 0;
        std::string Target;
        ObjectGuid Guid;
    };

    class UserClientPaidServiceCheat
    {
        ObjectGuid Guid;
        int32 ServiceID = 0;
    };

    class UserClientSetRaidDifficulty
    {
        int32 DifficultyID = 0;
    };

    class UserClientTutorial
    {
        TutorialAction Action;
        uint32 TutorialBit = 0;
    };

    class UserClientUndeleteCharacter
    {
        ObjectGuid CharacterGuid;
        int32 ClientToken = 0;
    };

    class UserClientSetLuckFactor
    {
        float LuckFactor = 0.0f;
    };

    class UserRouterClientSuspendCommsAck
    {
        uint32 Serial = 0;
        uint32 Timestamp = 0;
    };

    class UserRouterClientAuthSession
    {
        uint32 SiteID = 0;
        int8 LoginServerType = 0;
        int8 BuildType = 0;
        uint32 RealmID = 0;
        uint16 Build = 0;
        uint32 LocalChallenge = 0;
        int32 LoginServerID = 0;
        uint32 RegionID = 0;
        uint64 DosResponse = 0;
        uint8 Digest[20] = { };
        std::string Account;
        bool UseIPv6 = false;
        Data AddonInfo;
    };

    class UserRouterClientAuthContinuedSession
    {
        uint64 Key = 0;
        uint64 DosResponse = 0;
        uint8 Digest[20] = { };
    };

    class UserRouterClientPing
    {
        uint32 Serial = 0;
        uint32 Latency = 0;
    };

    class UserRouterClientLogDisconnect
    {
        uint32 Reason = 0;
    };

    class UserRouterClientSuspendTokenResponse
    {
        uint32 Sequence = 0;
    };

    class UserRouterClientQueuedMessagesEnd
    {
        uint32 Timestamp = 0;
    };

    class UserRouterClientLogStreamingError
    {
        std::string Error;
    };

    class JSONBnetChallengeFormInput
    {
        std::string Input_id;
        std::string Type;
        std::string Label;
        uint32 Max_length = 0;
        std::vector<Dynamicstd::string> Errors;
    };

    class JSONBnetChallengeForm
    {
        std::string Type;
        Dynamicstd::string Prompt;
        std::vector<Dynamicstd::string> Errors;
        std::vector<JSONBnetChallengeFormInput> Inputs;
    };

    class JSONBnetChallengeResponse
    {
        std::string Error_code;
        std::string Challenge_id;
        JSONBnetChallengeForm Challenge;
        bool Done = false;
    };

    class JSONBnetChallengeSubmissionInput
    {
        std::string Input_id;
        Dynamicstd::string Value;
    };

    class JSONBnetChallengeSubmission
    {
        std::vector<JSONBnetChallengeSubmissionInput> Inputs;
    };

    class JSONBnetCreateChallengeResponse
    {
        std::string Challenge_id;
        std::string Challenge_url;
    };

    class ServerBuckDataEntry
    {
        uint64 Arg = 0;
        std::string Argname;
        uint64 Count = 0;
        uint64 Accum = 0;
        uint64 Sqaccum = 0;
        uint64 Maximum = 0;
        uint64 Minimum = 0;
    };

    class ServerBuckDataList
    {
        uint32 MpID = 0;
        std::vector<ServerBuckDataEntry> Entries;
    };

    class PhaseShiftDataPhase
    {
        uint16 PhaseFlags = 0;
        uint16 Id = 0;
    };

    class PhaseShiftData
    {
        uint32 PhaseShiftFlags = 0;
        std::vector<PhaseShiftDataPhase> Phases;
        ObjectGuid PersonalGUID;
    };

    class SpawnTrackerData
    {
        std::vector<int32> QuestID;
    };

    class DumpObjectInfo
    {
        ObjectGuid Guid;
        float VisibleRange = 0.0f;
        Vector3 Position;
        uint32 DisplayID = 0;
        bool Granted = false;
    };

    class CliPetitionInfo
    {
        int32 PetitionID = 0;
        ObjectGuid Petitioner;
        std::string Title;
        std::string BodyText;
        int32 MinSignatures = 0;
        int32 MaxSignatures = 0;
        int32 DeadLine = 0;
        int32 IssueDate = 0;
        int32 AllowedGuildID = 0;
        int32 AllowedClasses = 0;
        int32 AllowedRaces = 0;
        int16 AllowedGender = 0;
        int32 AllowedMinLevel = 0;
        int32 AllowedMaxLevel = 0;
        int32 NumChoices = 0;
        int32 StaticType = 0;
        uint32 Muid = 0;
        std::string Choicetext[1] = { };
    };

    class BattlepayDisplayInfo
    {
        Optional<uint32> CreatureDisplayInfoID;
        Optional<uint32> FileDataID;
        std::string Name1;
        std::string Name2;
        std::string Name3;
        Optional<uint32> Flags;
    };

    class BattlepayProductItem
    {
        uint32 ID = 0;
        uint32 ItemID = 0;
        uint32 Quantity = 0;
        Optional<BattlepayDisplayInfo> DisplayInfo;
        bool HasPet = false;
        Optional<BATTLEPETRESULT> PetResult;
        bool HasMount = false;
    };

    class BattlePayProduct
    {
        uint32 ProductID = 0;
        uint64 NormalPriceFixedPoint = 0;
        uint64 CurrentPriceFixedPoint = 0;
        std::vector<BattlepayProductItem> Items;
        uint8 Type = 0;
        uint8 ChoiceType = 0;
        uint32 Flags = 0;
        Optional<BattlepayDisplayInfo> DisplayInfo;
    };

    class BattlePayProductGroup
    {
        uint32 GroupID = 0;
        std::string Name;
        int32 IconFileDataID = 0;
        uint8 DisplayType = 0;
        int32 Ordering = 0;
    };

    class BattlePayShopEntry
    {
        uint32 EntryID = 0;
        uint32 GroupID = 0;
        uint32 ProductID = 0;
        int32 Ordering = 0;
        uint32 Flags = 0;
        uint8 BannerType = 0;
        Optional<BattlepayDisplayInfo> DisplayInfo;
    };

    class BattlePayPurchase
    {
        uint64 PurchaseID = 0;
        uint32 Status = 0;
        uint32 ResultCode = 0;
        uint32 ProductID = 0;
        std::string WalletName;
    };

    class BattlePayDistributionObject
    {
        uint64 DistributionID = 0;
        uint32 Status = 0;
        uint32 ProductID = 0;
        ObjectGuid TargetPlayer;
        uint32 TargetVirtualRealm = 0;
        uint32 TargetNativeRealm = 0;
        uint64 PurchaseID = 0;
        Optional<BattlePayProduct> Product;
        bool Revoked = false;
    };

    class PlayerGuidLookupData
    {
        bool IsDeleted = false;
        uint32 AccountID = 0;
        ObjectGuid BnetAccountID;
        ObjectGuid GuidActual;
        std::string Name;
        uint32 VirtualRealmAddress = 0;
        uint8 Race = 0;
        uint8 Sex = 0;
        uint8 ClassID = 0;
        uint8 Level = 0;
        std::string DeclinedNames[5] = { };
    };

    class WhoWord
    {
        std::string Word;
    };

    class WhoRequestServerInfo
    {
        int32 FactionGroup = 0;
        int32 Locale = 0;
        uint32 RequesterVirtualRealmAddress = 0;
    };

    class WhoRequest
    {
        int32 MinLevel = 0;
        int32 MaxLevel = 0;
        std::string Name;
        std::string VirtualRealmName;
        std::string Guild;
        std::string GuildVirtualRealmName;
        int32 RaceFilter = 0;
        int32 ClassFilter = 0;
        std::vector<WhoWord> Words;
        bool ShowEnemies = false;
        bool ShowArenaPlayers = false;
        bool ExactName = false;
        Optional<WhoRequestServerInfo> ServerInfo;
    };

    class WhoEntry
    {
        PlayerGuidLookupData PlayerData;
        ObjectGuid GuildGUID;
        uint32 GuildVirtualRealmAddress = 0;
        std::string GuildName;
        int32 AreaID = 0;
        bool IsGM = false;
    };

    class WhoResponse
    {
        std::vector<WhoEntry> Entries;
    };

    class QualifiedGUID
    {
        ObjectGuid Guid;
        uint32 VirtualRealmAddress = 0;
    };

    class GarrisonFollower
    {
        uint64 DbID = 0;
        int32 GarrFollowerID = 0;
        int32 CreatureID = 0;
        int32 GarrGivenNameID = 0;
        int32 GarrFamilyNameID = 0;
        int32 Gender = 0;
        int32 Spec = 0;
        int32 Race = 0;
        int32 Quality = 0;
        int32 FollowerLevel = 0;
        int32 ItemLevelWeapon = 0;
        int32 ItemLevelArmor = 0;
        int32 Xp = 0;
        int32 CurrentBuildingID = 0;
        int32 CurrentMissionID = 0;
        std::vector<int32> AbilityID;
    };

    class GarrisonMission
    {
        uint64 DbID = 0;
        int32 MissionRecID = 0;
        time_t OfferTime = time_t(0);
        time_t OfferDuration = time_t(0);
        time_t StartTime = time_t(0);
        time_t TravelDuration = time_t(0);
        time_t MissionDuration = time_t(0);
        int32 MissionState = 0;
    };

    class CliMovementTransport
    {
        ObjectGuid Guid;
        Vector3 Position;
        float Facing = 0.0f;
        uint8 VehicleSeatIndex = 0;
        uint32 MoveTime = 0;
        Optional<uint32> PrevMoveTime;
        Optional<int32> VehicleRecID;
    };

    class CliMovementFallVelocity
    {
        Vector2 Direction;
        float Speed = 0.0f;
    };

    class CliMovementFallOrLand
    {
        uint32 Time = 0;
        float JumpVelocity = 0.0f;
        Optional<CliMovementFallVelocity> Velocity;
    };

    class CliMovementStatus
    {
        ObjectGuid MoverGUID;
        uint32 MoveFlags0 = 0;
        uint32 MoveFlags1 = 0;
        uint32 MoveTime = 0;
        Vector3 Position;
        float Facing = 0.0f;
        Optional<CliMovementTransport> Transport;
        float Pitch = 0.0f;
        Optional<CliMovementFallOrLand> Fall;
        float StepUpStartElevation = 0.0f;
        bool HasSpline = false;
        bool HeightChangeFailed = false;
        std::vector<uint32> RemoveForcesIDs;
        uint32 MoveIndex = 0;
        bool RemoteTimeValid = false;
    };

    class CliSplineFilterKey
    {
        float In = 0.0f;
        float Out = 0.0f;
    };

    class CliSplineFilter
    {
        std::vector<CliSplineFilterKey> FilterKeys;
        uint16 FilterFlags = 0;
    };

    class CliMovementSplineMove
    {
        uint32 Flags = 0;
        uint8 Face = 0;
        int32 Elapsed = 0;
        uint32 Duration = 0;
        float DurationModifier = 0.0f;
        float NextDurationModifier = 0.0f;
        Optional<float> JumpGravity;
        Optional<uint32> SpecialTime;
        std::vector<Vector3> Points;
        uint8 Mode = 0;
        Optional<CliSplineFilter> SplineFilter;
        float FaceDirection = 0.0f;
        ObjectGuid FaceGUID;
        Vector3 FaceSpot;
    };

    class CliMovementSpline
    {
        uint32 ID = 0;
        Vector3 Destination;
        Optional<CliMovementSplineMove> Move;
    };

    class MonsterSplineFilterKey
    {
        int16 Idx = 0;
        uint16 Speed = 0;
    };

    class MonsterSplineFilter
    {
        std::vector<MonsterSplineFilterKey> FilterKeys;
        uint16 FilterFlags = 0;
        float BaseSpeed = 0.0f;
        int16 StartOffset = 0;
        float DistToPrevFilterKey = 0.0f;
        int16 AddedToStart = 0;
    };

    class MovementSpline
    {
        uint32 Flags = 0;
        uint8 Face = 0;
        uint8 AnimTier = 0;
        uint32 TierTransStartTime = 0;
        int32 Elapsed = 0;
        uint32 MoveTime = 0;
        float JumpGravity = 0.0f;
        uint32 SpecialTime = 0;
        std::vector<Vector3> Points;
        uint8 Mode = 0;
        uint8 VehicleExitVoluntary = 0;
        ObjectGuid TransportGUID;
        int8 VehicleSeat = 0;
        std::vector<uint32> PackedDeltas;
        Optional<MonsterSplineFilter> SplineFilter;
        float FaceDirection = 0.0f;
        ObjectGuid FaceGUID;
        Vector3 FaceSpot;
    };

    class MovementMonsterSpline
    {
        uint32 ID = 0;
        Vector3 Destination;
        bool CrzTeleport = false;
        MovementSpline Move;
    };

    class CliMovementForce
    {
        uint32 ID = 0;
        Vector3 Direction;
        uint32 TransportID = 0;
        float Magnitude = 0.0f;
        uint8 Type = 0;
    };

    class CliMovementUpdate
    {
        CliMovementStatus Status;
        float WalkSpeed = 0.0f;
        float RunSpeed = 0.0f;
        float RunBackSpeed = 0.0f;
        float SwimSpeed = 0.0f;
        float SwimBackSpeed = 0.0f;
        float FlightSpeed = 0.0f;
        float FlightBackSpeed = 0.0f;
        float TurnRate = 0.0f;
        float PitchRate = 0.0f;
        Optional<CliMovementSpline> Spline;
        std::vector<CliMovementForce> MovementForces;
    };

    class CliPosition
    {
        Vector3 Position;
        float Facing = 0.0f;
    };

    class CliVehicleCreate
    {
        int32 RecID = 0;
        float InitialRawFacing = 0.0f;
    };

    class CliAnimKitCreate
    {
        uint16 AiID = 0;
        uint16 MovementID = 0;
        uint16 MeleeID = 0;
    };

    class CliAreaTriggerSphere
    {
        float Radius = 0.0f;
        float RadiusTarget = 0.0f;
    };

    class CliAreaTriggerCylinder
    {
        float Radius = 0.0f;
        float RadiusTarget = 0.0f;
        float Height = 0.0f;
        float HeightTarget = 0.0f;
    };

    class CliAreaTriggerBox
    {
        Vector3 Extents;
        Vector3 ExtentsTarget;
    };

    class CliAreaTriggerPolygon
    {
        std::vector<Vector2> Vertices;
        std::vector<Vector2> VerticesTarget;
        float Height = 0.0f;
        float HeightTarget = 0.0f;
    };

    class CliAreaTriggerSpline
    {
        uint32 TimeToTarget = 0;
        uint32 ElapsedTimeForMovement = 0;
        std::vector<Vector3> Points;
    };

    class CliAreaTrigger
    {
        uint32 ElapsedMs = 0;
        bool AbsoluteOrientation = false;
        bool DynamicShape = false;
        bool Attached = false;
        bool FaceMovementDir = false;
        bool FollowsTerrain = false;
        Vector3 RollPitchYaw;
        Optional<Vector3> TargetRollPitchYaw;
        Optional<uint32> ScaleCurveID;
        Optional<uint32> MorphCurveID;
        Optional<uint32> FacingCurveID;
        Optional<uint32> MoveCurveID;
        Optional<CliAreaTriggerSphere> AreaTriggerSphere;
        Optional<CliAreaTriggerBox> AreaTriggerBox;
        Optional<CliAreaTriggerPolygon> AreaTriggerPolygon;
        Optional<CliAreaTriggerCylinder> AreaTriggerCylinder;
        Optional<CliAreaTriggerSpline> AreaTriggerSpline;
    };

    class CliGameObject
    {
        uint32 WorldEffectID = 0;
    };

    class CliSceneLocalScriptData
    {
        std::string Data;
    };

    class CliPlayerSceneInstances
    {
        std::vector<uint32> SceneInstanceIDs;
    };

    class VignetteInstanceIDList
    {
        std::vector<ObjectGuid> IDs;
    };

    class VignetteClientData
    {
        ObjectGuid ObjGUID;
        Vector3 Position;
        int32 VignetteID = 0;
    };

    class VignetteClientDataSet
    {
        VignetteInstanceIDList IdList;
        std::vector<VignetteClientData> Data;
    };

    class CliSceneObjCreate
    {
        Optional<CliSceneLocalScriptData> LocalScriptData;
        Optional<PetBattleFullUpdate> PetBattleFullUpdate;
    };

    class CliObjCreate
    {
        bool NoBirthAnim = false;
        bool EnablePortals = false;
        bool PlayHoverAnim = false;
        bool IsSuppressingGreetings = false;
        Optional<CliMovementUpdate> Move;
        Optional<CliMovementTransport> Passenger;
        Optional<CliPosition> Stationary;
        Optional<ObjectGuid> CombatVictim;
        Optional<uint32> ServerTime;
        Optional<CliVehicleCreate> Vehicle;
        Optional<CliAnimKitCreate> AnimKit;
        Optional<long> Rotation;
        Optional<CliAreaTrigger> AreaTrigger;
        Optional<CliGameObject> GameObject;
        bool ThisIsYou = false;
        bool ReplaceActive = false;
        Optional<CliSceneObjCreate> SceneObjCreate;
        Optional<CliPlayerSceneInstances> ScenePendingInstances;
        std::vector<uint32> PauseTimes;
    };

    class PetBattleInput
    {
        uint8 MoveType = 0;
        int8 NewFrontPet = 0;
        uint8 DebugFlags = 0;
        uint8 BattleInterrupted = 0;
        bool IgnoreAbandonPenalty = false;
        int32 AbilityID = 0;
        int32 Round = 0;
    };

    class PetBattleLocations
    {
        int32 LocationResult = 0;
        Vector3 BattleOrigin;
        float BattleFacing = 0.0f;
        Vector3 PlayerPositions[2] = { };
    };

    class PetBattleActiveAbility
    {
        int32 AbilityID = 0;
        int16 CooldownRemaining = 0;
        int16 LockdownRemaining = 0;
        int8 AbilityIndex = 0;
        uint8 Pboid = 0;
    };

    class PetBattleActiveAura
    {
        int32 AbilityID = 0;
        uint32 InstanceID = 0;
        int32 RoundsRemaining = 0;
        int32 CurrentRound = 0;
        uint8 CasterPBOID = 0;
    };

    class PetBattleActiveState
    {
        uint32 StateID = 0;
        int32 StateValue = 0;
    };

    class PetBattlePetUpdate
    {
        ObjectGuid BattlePetGUID;
        int32 SpeciesID = 0;
        int32 DisplayID = 0;
        int32 CollarID = 0;
        int16 Level = 0;
        int16 Xp = 0;
        int32 CurHealth = 0;
        int32 MaxHealth = 0;
        int32 Power = 0;
        int32 Speed = 0;
        int32 NpcTeamMemberID = 0;
        uint16 BreedQuality = 0;
        uint16 StatusFlags = 0;
        int8 Slot = 0;
        std::string CustomName;
        std::vector<PetBattleActiveAbility> Abilities;
        std::vector<PetBattleActiveAura> Auras;
        std::vector<PetBattleActiveState> States;
    };

    class PetBattlePlayerUpdate
    {
        ObjectGuid CharacterID;
        int32 TrapAbilityID = 0;
        int32 TrapStatus = 0;
        uint16 RoundTimeSecs = 0;
        std::vector<PetBattlePetUpdate> Pets;
        int8 FrontPet = 0;
        uint8 InputFlags = 0;
    };

    class PetBattleEnviroUpdate
    {
        std::vector<PetBattleActiveAura> Auras;
        std::vector<PetBattleActiveState> States;
    };

    class PetBattleFullUpdate
    {
        uint16 WaitingForFrontPetsMaxSecs = 0;
        uint16 PvpMaxRoundTime = 0;
        int32 CurRound = 0;
        uint32 NpcCreatureID = 0;
        uint32 NpcDisplayID = 0;
        int8 CurPetBattleState = 0;
        uint8 ForfeitPenalty = 0;
        ObjectGuid InitialWildPetGUID;
        bool IsPVP = false;
        bool CanAwardXP = false;
        PetBattlePlayerUpdate Players[2] = { };
        PetBattleEnviroUpdate Enviros[3] = { };
    };

    class PetBattleEffectTarget
    {
        PetBattleEffectTargetEx Type;
        uint8 Petx = 0;
        uint32 AuraInstanceID = 0;
        uint32 AuraAbilityID = 0;
        int32 RoundsRemaining = 0;
        int32 CurrentRound = 0;
        uint32 StateID = 0;
        int32 StateValue = 0;
        int32 Health = 0;
        int32 NewStatValue = 0;
        int32 TriggerAbilityID = 0;
        int32 ChangedAbilityID = 0;
        int32 CooldownRemaining = 0;
        int32 LockdownRemaining = 0;
        int32 BroadcastTextID = 0;
    };

    class PetBattleEffect
    {
        uint32 AbilityEffectID = 0;
        uint16 Flags = 0;
        uint16 SourceAuraInstanceID = 0;
        uint16 TurnInstanceID = 0;
        int8 PetBattleEffectType = 0;
        uint8 CasterPBOID = 0;
        uint8 StackDepth = 0;
        std::vector<PetBattleEffectTarget> Targets;
    };

    class PetBattleRoundResult
    {
        int32 CurRound = 0;
        int8 NextPetBattleState = 0;
        std::vector<PetBattleEffect> Effects;
        std::vector<int8> PetXDied;
        std::vector<PetBattleActiveAbility> Cooldowns;
        uint8 NextInputFlags[2] = { };
        int8 NextTrapStatus[2] = { };
        uint16 RoundTimeSecs[2] = { };
    };

    class PetBattleFinalPet
    {
        bool Captured = false;
        bool Caged = false;
        bool AwardedXP = false;
        bool SeenAction = false;
        uint16 Level = 0;
        uint16 Xp = 0;
        int32 Health = 0;
        int32 MaxHealth = 0;
        uint16 InitialLevel = 0;
        uint8 Pboid = 0;
    };

    class PetBattleFinalRound
    {
        bool Abandoned = false;
        bool PvpBattle = false;
        std::vector<PetBattleFinalPet> Pets;
        bool Winners[2] = { };
        int32 NpcCreatureID[2] = { };
    };

    class PetBattleMaxGameLengthWarning
    {
        time_t TimeRemaining = time_t(0);
        int32 RoundsRemaining = 0;
    };

    class Location
    {
        ObjectGuid Transport;
        Vector3 Location;
    };

    class SpellPowerData
    {
        int32 Cost = 0;
        int8 Type = 0;
    };

    class RuneData
    {
        uint8 Start = 0;
        uint8 Count = 0;
        std::vector<uint8> Cooldowns;
    };

    class SpellMissStatus
    {
        uint8 Reason = 0;
        uint8 ReflectStatus = 0;
    };

    class MissileTrajectoryResult
    {
        uint32 TravelTime = 0;
        float Pitch = 0.0f;
    };

    class SpellAmmo
    {
        int32 DisplayID = 0;
        int8 InventoryType = 0;
    };

    class SpellHealPrediction
    {
        ObjectGuid BeaconGUID;
        int32 Points = 0;
        uint8 Type = 0;
    };

    class CreatureImmunities
    {
        int32 School = 0;
        int32 Value = 0;
    };

    class ProjectileVisual
    {
        int32 Id[2] = { };
    };

    class SpellTargetData
    {
        uint32 Flags = 0;
        ObjectGuid Unit;
        ObjectGuid Item;
        Optional<Location> SrcLocation;
        Optional<Location> DstLocation;
        std::string Name;
    };

    class SpellCastData
    {
        ObjectGuid CasterGUID;
        ObjectGuid CasterUnit;
        uint8 CastID = 0;
        int32 SpellID = 0;
        uint32 CastFlags = 0;
        uint32 CastFlagsEx = 0;
        uint32 CastTime = 0;
        std::vector<ObjectGuid> HitTargets;
        std::vector<ObjectGuid> MissTargets;
        std::vector<SpellMissStatus> MissStatus;
        SpellTargetData Target;
        std::vector<SpellPowerData> RemainingPower;
        Optional<RuneData> RemainingRunes;
        MissileTrajectoryResult MissileTrajectory;
        SpellAmmo Ammo;
        Optional<ProjectileVisual> ProjectileVisual;
        uint8 DestLocSpellCastIndex = 0;
        std::vector<Location> TargetPoints;
        CreatureImmunities Immunities;
        SpellHealPrediction Predict;
    };

    class SpellLogPowerData
    {
        int32 PowerType = 0;
        int32 Amount = 0;
    };

    class SpellCastLogData
    {
        int32 Health = 0;
        int32 AttackPower = 0;
        int32 SpellPower = 0;
        std::vector<SpellLogPowerData> PowerData;
    };

    class PeriodicAuraLogEffectDebugInfo
    {
        float CritRollMade = 0.0f;
        float CritRollNeeded = 0.0f;
    };

    class PeriodicAuraLogEffect
    {
        int32 Effect = 0;
        int32 Amount = 0;
        int32 OverHealOrKill = 0;
        int32 SchoolMaskOrPower = 0;
        int32 AbsorbedOrAmplitude = 0;
        int32 Resisted = 0;
        bool Crit = false;
        bool Multistrike = false;
        Optional<PeriodicAuraLogEffectDebugInfo> DebugInfo;
    };

    class SpellProcsPerMinuteCalc
    {
        int32 Type = 0;
        int32 Param = 0;
        float Coeff = 0.0f;
        float Input = 0.0f;
        float NewValue = 0.0f;
    };

    class SpellProcsPerMinuteLogData
    {
        bool Proc = false;
        int32 SpellID = 0;
        float BaseProcRate = 0.0f;
        uint32 Now = 0;
        uint32 LastChanceTimestamp = 0;
        uint32 LastProcTimestamp = 0;
        uint32 LastChanceTime = 0;
        uint32 LastProcTime = 0;
        bool NormalizeAuraTime = false;
        uint32 AuraTime = 0;
        float int32ervalsSinceLastProc = 0.0f;
        float UnluckyStreakDef = 0.0f;
        float UnluckyMultiplier = 0.0f;
        int32 ReallyUnluckyDef = 0;
        float ProcChance = 0.0f;
        float ProcRate = 0.0f;
        float Roll = 0.0f;
        std::vector<SpellProcsPerMinuteCalc> CalcHistory;
    };

    class PetSpellCooldown
    {
        int32 SpellID = 0;
        int32 Duration = 0;
        int32 CategoryDuration = 0;
        uint16 Category = 0;
    };

    class PetSpellHistory
    {
        int32 CategoryID = 0;
        int32 RecoveryTime = 0;
        int8 ConsumedCharges = 0;
    };

    class ClientPetSpells
    {
        ObjectGuid PetGUID;
        uint16 CreatureFamily = 0;
        uint16 Specialization = 0;
        uint32 TimeLimit = 0;
        uint32 PetModeAndOrders = 0;
        std::vector<uint32> Actions;
        std::vector<PetSpellCooldown> Cooldowns;
        std::vector<PetSpellHistory> SpellHistory;
        uint32 ActionButtons[10] = { };
    };