/*
 * Copyright (C) 2008-2018 TrinityCore <http://www.trinitycore.org/>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

// DO NOT EDIT!
// Autogenerated from DB2Structure.h

#ifndef DB2LoadInfo_h__
#define DB2LoadInfo_h__

#include "DB2DatabaseLoader.h"
#include "DB2Metadata.h"
#include "Implementation/HotfixDatabase.h"

struct AchievementLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Title" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "Reward" },
            { true, FT_INT, "Flags" },
            { true, FT_SHORT, "InstanceID" },
            { true, FT_SHORT, "Supercedes" },
            { true, FT_SHORT, "Category" },
            { true, FT_SHORT, "UiOrder" },
            { true, FT_SHORT, "SharesCriteria" },
            { true, FT_BYTE, "Faction" },
            { true, FT_BYTE, "Points" },
            { true, FT_BYTE, "MinimumCriteria" },
            { false, FT_INT, "ID" },
            { true, FT_INT, "IconFileID" },
            { false, FT_INT, "CriteriaTree" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AchievementMeta::Instance(), HOTFIX_SEL_ACHIEVEMENT);
        return &loadInfo;
    }
};

struct Achievement_CategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "Parent" },
            { false, FT_BYTE, "UiOrder" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Achievement_CategoryMeta::Instance(), HOTFIX_SEL_ACHIEVEMENT__CATEGORY);
        return &loadInfo;
    }
};

struct AdventureJournalLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "ButtonText" },
            { false, FT_STRING, "RewardDescription" },
            { false, FT_STRING, "ContinueDescription" },
            { true, FT_INT, "TextureFileDataID" },
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "LfgDungeonID" },
            { false, FT_SHORT, "QuestID" },
            { false, FT_SHORT, "BattleMasterListID" },
            { false, FT_SHORT, "BonusPlayerConditionID1" },
            { false, FT_SHORT, "BonusPlayerConditionID2" },
            { false, FT_SHORT, "CurrencyType" },
            { false, FT_SHORT, "WorldMapAreaID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "ButtonActionType" },
            { false, FT_BYTE, "PriorityMin" },
            { false, FT_BYTE, "PriorityMax" },
            { false, FT_BYTE, "BonusValue1" },
            { false, FT_BYTE, "BonusValue2" },
            { false, FT_BYTE, "CurrencyQuantity" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "ItemQuantity" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AdventureJournalMeta::Instance(), HOTFIX_SEL_ADVENTURE_JOURNAL);
        return &loadInfo;
    }
};

struct AdventureMapPOILoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Title" },
            { false, FT_STRING, "Description" },
            { false, FT_FLOAT, "WorldPosition1" },
            { false, FT_FLOAT, "WorldPosition2" },
            { true, FT_INT, "RewardItemID" },
            { false, FT_BYTE, "Type" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "QuestID" },
            { true, FT_INT, "LfgDungeonID" },
            { true, FT_INT, "UiTextureAtlasMemberID" },
            { true, FT_INT, "UiTextureKitID" },
            { true, FT_INT, "WorldMapAreaID" },
            { true, FT_INT, "DungeonMapID" },
            { true, FT_INT, "AreaTableID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AdventureMapPOIMeta::Instance(), HOTFIX_SEL_ADVENTURE_MAP_P_O_I);
        return &loadInfo;
    }
};

struct AlliedRaceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "BannerColor" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "RaceID" },
            { true, FT_INT, "CrestTextureID" },
            { true, FT_INT, "ModelBackgroundTextureID" },
            { true, FT_INT, "MaleCreatureDisplayID" },
            { true, FT_INT, "FemaleCreatureDisplayID" },
            { true, FT_INT, "UiUnlockAchievementID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AlliedRaceMeta::Instance(), HOTFIX_SEL_ALLIED_RACE);
        return &loadInfo;
    }
};

struct AlliedRaceRacialAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_INT, "IconFileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AlliedRaceRacialAbilityMeta::Instance(), HOTFIX_SEL_ALLIED_RACE_RACIAL_ABILITY);
        return &loadInfo;
    }
};

struct AnimationDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Flags" },
            { false, FT_SHORT, "Fallback" },
            { false, FT_SHORT, "BehaviorID" },
            { false, FT_BYTE, "BehaviorTier" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimationDataMeta::Instance(), HOTFIX_SEL_ANIMATION_DATA);
        return &loadInfo;
    }
};

struct AnimKitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "OneShotDuration" },
            { false, FT_SHORT, "OneShotStopAnimKitID" },
            { false, FT_SHORT, "LowDefAnimKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitMeta::Instance(), HOTFIX_SEL_ANIM_KIT);
        return &loadInfo;
    }
};

struct AnimKitBoneSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "BoneDataID" },
            { false, FT_BYTE, "ParentAnimKitBoneSetID" },
            { false, FT_BYTE, "ExtraBoneCount" },
            { false, FT_BYTE, "AltAnimKitBoneSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitBoneSetMeta::Instance(), HOTFIX_SEL_ANIM_KIT_BONE_SET);
        return &loadInfo;
    }
};

struct AnimKitBoneSetAliasLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "BoneDataID" },
            { false, FT_BYTE, "AnimKitBoneSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitBoneSetAliasMeta::Instance(), HOTFIX_SEL_ANIM_KIT_BONE_SET_ALIAS);
        return &loadInfo;
    }
};

struct AnimKitConfigLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ConfigFlags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitConfigMeta::Instance(), HOTFIX_SEL_ANIM_KIT_CONFIG);
        return &loadInfo;
    }
};

struct AnimKitConfigBoneSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "AnimKitPriorityID" },
            { false, FT_BYTE, "AnimKitBoneSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitConfigBoneSetMeta::Instance(), HOTFIX_SEL_ANIM_KIT_CONFIG_BONE_SET);
        return &loadInfo;
    }
};

struct AnimKitPriorityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Priority" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitPriorityMeta::Instance(), HOTFIX_SEL_ANIM_KIT_PRIORITY);
        return &loadInfo;
    }
};

struct AnimKitReplacementLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "SrcAnimKitID" },
            { false, FT_SHORT, "DstAnimKitID" },
            { false, FT_SHORT, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitReplacementMeta::Instance(), HOTFIX_SEL_ANIM_KIT_REPLACEMENT);
        return &loadInfo;
    }
};

struct AnimKitSegmentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "AnimStartTime" },
            { true, FT_INT, "EndConditionParam" },
            { true, FT_INT, "EndConditionDelay" },
            { false, FT_FLOAT, "Speed" },
            { false, FT_INT, "OverrideConfigFlags" },
            { false, FT_SHORT, "ParentAnimKitID" },
            { false, FT_SHORT, "AnimID" },
            { false, FT_SHORT, "AnimKitConfigID" },
            { false, FT_SHORT, "SegmentFlags" },
            { false, FT_SHORT, "BlendInTimeMs" },
            { false, FT_SHORT, "BlendOutTimeMs" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "StartCondition" },
            { false, FT_BYTE, "StartConditionParam" },
            { false, FT_BYTE, "EndCondition" },
            { false, FT_BYTE, "ForcedVariation" },
            { false, FT_BYTE, "LoopToSegmentIndex" },
            { true, FT_INT, "StartConditionDelay" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimKitSegmentMeta::Instance(), HOTFIX_SEL_ANIM_KIT_SEGMENT);
        return &loadInfo;
    }
};

struct AnimReplacementLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "SrcAnimID" },
            { false, FT_SHORT, "DstAnimID" },
            { false, FT_SHORT, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimReplacementMeta::Instance(), HOTFIX_SEL_ANIM_REPLACEMENT);
        return &loadInfo;
    }
};

struct AnimReplacementSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "ExecOrder" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AnimReplacementSetMeta::Instance(), HOTFIX_SEL_ANIM_REPLACEMENT_SET);
        return &loadInfo;
    }
};

struct AreaFarClipOverrideLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "AreaID" },
            { false, FT_FLOAT, "MinFarClip" },
            { false, FT_FLOAT, "MinHorizonStart" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaFarClipOverrideMeta::Instance(), HOTFIX_SEL_AREA_FAR_CLIP_OVERRIDE);
        return &loadInfo;
    }
};

struct AreaGroupMemberLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "AreaGroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaGroupMemberMeta::Instance(), HOTFIX_SEL_AREA_GROUP_MEMBER);
        return &loadInfo;
    }
};

struct AreaPOILoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "Flags" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_FLOAT, "Pos3" },
            { true, FT_INT, "PoiDataType" },
            { true, FT_INT, "PoiData" },
            { false, FT_SHORT, "ContinentID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "WorldStateID" },
            { false, FT_BYTE, "Importance" },
            { false, FT_BYTE, "Icon" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "PortLocID" },
            { true, FT_INT, "UiTextureAtlasMemberID" },
            { true, FT_INT, "MapFloor" },
            { true, FT_INT, "WmoGroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaPOIMeta::Instance(), HOTFIX_SEL_AREA_P_O_I);
        return &loadInfo;
    }
};

struct AreaPOIStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { false, FT_BYTE, "WorldStateValue" },
            { false, FT_BYTE, "IconEnumValue" },
            { true, FT_INT, "UiTextureAtlasMemberID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaPOIStateMeta::Instance(), HOTFIX_SEL_AREA_P_O_I_STATE);
        return &loadInfo;
    }
};

struct AreaTableLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "ZoneName" },
            { false, FT_STRING, "AreaName" },
            { false, FT_INT, "Flags1" },
            { false, FT_INT, "Flags2" },
            { false, FT_FLOAT, "AmbientMultiplier" },
            { false, FT_SHORT, "ContinentID" },
            { false, FT_SHORT, "ParentAreaID" },
            { true, FT_SHORT, "AreaBit" },
            { false, FT_SHORT, "AmbienceID" },
            { false, FT_SHORT, "ZoneMusic" },
            { false, FT_SHORT, "IntroSound" },
            { false, FT_SHORT, "LiquidTypeID1" },
            { false, FT_SHORT, "LiquidTypeID2" },
            { false, FT_SHORT, "LiquidTypeID3" },
            { false, FT_SHORT, "LiquidTypeID4" },
            { false, FT_SHORT, "UwZoneMusic" },
            { false, FT_SHORT, "UwAmbience" },
            { false, FT_SHORT, "PvpCombatWorldStateID" },
            { false, FT_BYTE, "SoundProviderPref" },
            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
            { true, FT_BYTE, "ExplorationLevel" },
            { false, FT_BYTE, "FactionGroupMask" },
            { false, FT_BYTE, "MountFlags" },
            { false, FT_BYTE, "WildBattlePetLevelMin" },
            { false, FT_BYTE, "WildBattlePetLevelMax" },
            { false, FT_BYTE, "WindSettingsID" },
            { true, FT_INT, "UwIntroSound" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTableMeta::Instance(), HOTFIX_SEL_AREA_TABLE);
        return &loadInfo;
    }
};

struct AreaTriggerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "PosX" },
            { false, FT_FLOAT, "PosY" },
            { false, FT_FLOAT, "PosZ" },
            { false, FT_FLOAT, "Radius" },
            { false, FT_FLOAT, "BoxLength" },
            { false, FT_FLOAT, "BoxWidth" },
            { false, FT_FLOAT, "BoxHeight" },
            { false, FT_FLOAT, "BoxYaw" },
            { false, FT_SHORT, "ContinentID" },
            { false, FT_SHORT, "PhaseID" },
            { false, FT_SHORT, "PhaseGroupID" },
            { false, FT_SHORT, "ShapeID" },
            { false, FT_SHORT, "AreaTriggerActionSetID" },
            { false, FT_BYTE, "PhaseUseFlags" },
            { false, FT_BYTE, "ShapeType" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER);
        return &loadInfo;
    }
};

struct AreaTriggerActionSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerActionSetMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER_ACTION_SET);
        return &loadInfo;
    }
};

struct AreaTriggerBoxLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Extents1" },
            { false, FT_FLOAT, "Extents2" },
            { false, FT_FLOAT, "Extents3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerBoxMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER_BOX);
        return &loadInfo;
    }
};

struct AreaTriggerCylinderLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Radius" },
            { false, FT_FLOAT, "Height" },
            { false, FT_FLOAT, "ZOffset" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerCylinderMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER_CYLINDER);
        return &loadInfo;
    }
};

struct AreaTriggerSphereLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "MaxRadius" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AreaTriggerSphereMeta::Instance(), HOTFIX_SEL_AREA_TRIGGER_SPHERE);
        return &loadInfo;
    }
};

struct ArmorLocationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Clothmodifier" },
            { false, FT_FLOAT, "Leathermodifier" },
            { false, FT_FLOAT, "Chainmodifier" },
            { false, FT_FLOAT, "Platemodifier" },
            { false, FT_FLOAT, "Modifier" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArmorLocationMeta::Instance(), HOTFIX_SEL_ARMOR_LOCATION);
        return &loadInfo;
    }
};

struct ArtifactLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_INT, "UiBarOverlayColor" },
            { false, FT_INT, "UiBarBackgroundColor" },
            { false, FT_INT, "UiNameColor" },
            { false, FT_SHORT, "UiTextureKitID" },
            { false, FT_SHORT, "ChrSpecializationID" },
            { false, FT_BYTE, "ArtifactCategoryID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "UiModelSceneID" },
            { true, FT_INT, "SpellVisualKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactMeta::Instance(), HOTFIX_SEL_ARTIFACT);
        return &loadInfo;
    }
};

struct ArtifactAppearanceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_INT, "UiSwatchColor" },
            { false, FT_FLOAT, "UiModelSaturation" },
            { false, FT_FLOAT, "UiModelOpacity" },
            { true, FT_INT, "OverrideShapeshiftDisplayID" },
            { false, FT_SHORT, "ArtifactAppearanceSetID" },
            { false, FT_SHORT, "UiCameraID" },
            { false, FT_BYTE, "DisplayIndex" },
            { false, FT_BYTE, "ItemAppearanceModifierID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "OverrideShapeshiftFormID" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "UnlockPlayerConditionID" },
            { true, FT_INT, "UiItemAppearanceID" },
            { true, FT_INT, "UiAltItemAppearanceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactAppearanceMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE);
        return &loadInfo;
    }
};

struct ArtifactAppearanceSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_SHORT, "UiCameraID" },
            { false, FT_SHORT, "AltHandUICameraID" },
            { false, FT_BYTE, "DisplayIndex" },
            { false, FT_BYTE, "ForgeAttachmentOverride" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "ArtifactID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactAppearanceSetMeta::Instance(), HOTFIX_SEL_ARTIFACT_APPEARANCE_SET);
        return &loadInfo;
    }
};

struct ArtifactCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "XpMultCurrencyID" },
            { false, FT_SHORT, "XpMultCurveID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactCategoryMeta::Instance(), HOTFIX_SEL_ARTIFACT_CATEGORY);
        return &loadInfo;
    }
};

struct ArtifactPowerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "DisplayPos1" },
            { false, FT_FLOAT, "DisplayPos2" },
            { false, FT_BYTE, "ArtifactID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "MaxPurchasableRank" },
            { false, FT_BYTE, "Tier" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "Label" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER);
        return &loadInfo;
    }
};

struct ArtifactPowerLinkLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "PowerA" },
            { false, FT_SHORT, "PowerB" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerLinkMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_LINK);
        return &loadInfo;
    }
};

struct ArtifactPowerPickerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "PlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerPickerMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_PICKER);
        return &loadInfo;
    }
};

struct ArtifactPowerRankLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_FLOAT, "AuraPointsOverride" },
            { false, FT_SHORT, "ItemBonusListID" },
            { false, FT_BYTE, "RankIndex" },
            { false, FT_SHORT, "ArtifactPowerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactPowerRankMeta::Instance(), HOTFIX_SEL_ARTIFACT_POWER_RANK);
        return &loadInfo;
    }
};

struct ArtifactQuestXpLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Difficulty1" },
            { true, FT_INT, "Difficulty2" },
            { true, FT_INT, "Difficulty3" },
            { true, FT_INT, "Difficulty4" },
            { true, FT_INT, "Difficulty5" },
            { true, FT_INT, "Difficulty6" },
            { true, FT_INT, "Difficulty7" },
            { true, FT_INT, "Difficulty8" },
            { true, FT_INT, "Difficulty9" },
            { true, FT_INT, "Difficulty10" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactQuestXPMeta::Instance(), HOTFIX_SEL_ARTIFACT_QUEST_XP);
        return &loadInfo;
    }
};

struct ArtifactTierLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ArtifactTier" },
            { true, FT_INT, "MaxNumTraits" },
            { true, FT_INT, "MaxArtifactKnowledge" },
            { true, FT_INT, "KnowledgePlayerCondition" },
            { true, FT_INT, "MinimumEmpowerKnowledge" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactTierMeta::Instance(), HOTFIX_SEL_ARTIFACT_TIER);
        return &loadInfo;
    }
};

struct ArtifactUnlockLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ItemBonusListID" },
            { false, FT_BYTE, "PowerRank" },
            { true, FT_INT, "PowerID" },
            { true, FT_INT, "PlayerConditionID" },
            { false, FT_BYTE, "ArtifactID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ArtifactUnlockMeta::Instance(), HOTFIX_SEL_ARTIFACT_UNLOCK);
        return &loadInfo;
    }
};

struct AuctionHouseLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "FactionID" },
            { false, FT_BYTE, "DepositRate" },
            { false, FT_BYTE, "ConsignmentRate" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, AuctionHouseMeta::Instance(), HOTFIX_SEL_AUCTION_HOUSE);
        return &loadInfo;
    }
};

struct BankBagSlotPricesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Cost" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BankBagSlotPricesMeta::Instance(), HOTFIX_SEL_BANK_BAG_SLOT_PRICES);
        return &loadInfo;
    }
};

struct BannedAddonsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Version" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BannedAddonsMeta::Instance(), HOTFIX_SEL_BANNED_ADDONS);
        return &loadInfo;
    }
};

struct BarberShopStyleLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "DisplayName" },
            { false, FT_STRING, "Description" },
            { false, FT_FLOAT, "CostModifier" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "Race" },
            { false, FT_BYTE, "Sex" },
            { false, FT_BYTE, "Data" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BarberShopStyleMeta::Instance(), HOTFIX_SEL_BARBER_SHOP_STYLE);
        return &loadInfo;
    }
};

struct BattlemasterListLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "GameType" },
            { false, FT_STRING, "ShortDescription" },
            { false, FT_STRING, "LongDescription" },
            { true, FT_INT, "IconFileDataID" },
            { true, FT_SHORT, "MapID1" },
            { true, FT_SHORT, "MapID2" },
            { true, FT_SHORT, "MapID3" },
            { true, FT_SHORT, "MapID4" },
            { true, FT_SHORT, "MapID5" },
            { true, FT_SHORT, "MapID6" },
            { true, FT_SHORT, "MapID7" },
            { true, FT_SHORT, "MapID8" },
            { true, FT_SHORT, "MapID9" },
            { true, FT_SHORT, "MapID10" },
            { true, FT_SHORT, "MapID11" },
            { true, FT_SHORT, "MapID12" },
            { true, FT_SHORT, "MapID13" },
            { true, FT_SHORT, "MapID14" },
            { true, FT_SHORT, "MapID15" },
            { true, FT_SHORT, "MapID16" },
            { false, FT_SHORT, "HolidayWorldState" },
            { false, FT_SHORT, "RequiredPlayer_Condition_ID" },
            { false, FT_BYTE, "InstanceType" },
            { false, FT_BYTE, "GroupsAllowed" },
            { false, FT_BYTE, "MaxGroupSize" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "MaxLevel" },
            { false, FT_BYTE, "RatedPlayers" },
            { false, FT_BYTE, "MinPlayers" },
            { false, FT_BYTE, "MaxPlayers" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlemasterListMeta::Instance(), HOTFIX_SEL_BATTLEMASTER_LIST);
        return &loadInfo;
    }
};

struct BattlePetAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_SHORT, "BattlePetVisualID" },
            { false, FT_BYTE, "PetTypeEnum" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "Cooldown" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetAbilityMeta::Instance(), HOTFIX_SEL_BATTLE_PET_ABILITY);
        return &loadInfo;
    }
};

struct BattlePetAbilityEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "BattlePetAbilityTurnID" },
            { false, FT_SHORT, "BattlePetVisualID" },
            { false, FT_SHORT, "AuraBattlePetAbilityID" },
            { false, FT_SHORT, "BattlePetEffectPropertiesID" },
            { false, FT_SHORT, "Param1" },
            { false, FT_SHORT, "Param2" },
            { false, FT_SHORT, "Param3" },
            { false, FT_SHORT, "Param4" },
            { false, FT_SHORT, "Param5" },
            { false, FT_SHORT, "Param6" },
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetAbilityEffectMeta::Instance(), HOTFIX_SEL_BATTLE_PET_ABILITY_EFFECT);
        return &loadInfo;
    }
};

struct BattlePetAbilityStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Value" },
            { false, FT_BYTE, "BattlePetStateID" },
            { false, FT_SHORT, "BattlePetAbilityID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetAbilityStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_ABILITY_STATE);
        return &loadInfo;
    }
};

struct BattlePetAbilityTurnLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "BattlePetAbilityID" },
            { false, FT_SHORT, "BattlePetVisualID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "TurnTypeEnum" },
            { false, FT_BYTE, "EventTypeEnum" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetAbilityTurnMeta::Instance(), HOTFIX_SEL_BATTLE_PET_ABILITY_TURN);
        return &loadInfo;
    }
};

struct BattlePetBreedQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "StateMultiplier" },
            { false, FT_BYTE, "QualityEnum" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetBreedQualityMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_QUALITY);
        return &loadInfo;
    }
};

struct BattlePetBreedStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Value" },
            { false, FT_BYTE, "BattlePetStateID" },
            { false, FT_BYTE, "BreedID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetBreedStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_BREED_STATE);
        return &loadInfo;
    }
};

struct BattlePetDisplayOverrideLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "BattlePetSpeciesID" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "CreatureDisplayInfoID" },
            { false, FT_BYTE, "PriorityCategory" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetDisplayOverrideMeta::Instance(), HOTFIX_SEL_BATTLE_PET_DISPLAY_OVERRIDE);
        return &loadInfo;
    }
};

struct BattlePetEffectPropertiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "ParamLabel1" },
            { false, FT_STRING, "ParamLabel2" },
            { false, FT_STRING, "ParamLabel3" },
            { false, FT_STRING, "ParamLabel4" },
            { false, FT_STRING, "ParamLabel5" },
            { false, FT_STRING, "ParamLabel6" },
            { false, FT_SHORT, "BattlePetVisualID" },
            { false, FT_BYTE, "ParamTypeEnum1" },
            { false, FT_BYTE, "ParamTypeEnum2" },
            { false, FT_BYTE, "ParamTypeEnum3" },
            { false, FT_BYTE, "ParamTypeEnum4" },
            { false, FT_BYTE, "ParamTypeEnum5" },
            { false, FT_BYTE, "ParamTypeEnum6" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetEffectPropertiesMeta::Instance(), HOTFIX_SEL_BATTLE_PET_EFFECT_PROPERTIES);
        return &loadInfo;
    }
};

struct BattlePetNPCTeamMemberLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetNPCTeamMemberMeta::Instance(), HOTFIX_SEL_BATTLE_PET_N_P_C_TEAM_MEMBER);
        return &loadInfo;
    }
};

struct BattlePetSpeciesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "SourceText" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "CreatureID" },
            { true, FT_INT, "IconFileDataID" },
            { true, FT_INT, "SummonSpellID" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "PetTypeEnum" },
            { false, FT_BYTE, "SourceTypeEnum" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "CardUIModelSceneID" },
            { true, FT_INT, "LoadoutUIModelSceneID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetSpeciesMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES);
        return &loadInfo;
    }
};

struct BattlePetSpeciesStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Value" },
            { false, FT_BYTE, "BattlePetStateID" },
            { false, FT_SHORT, "SpeciesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetSpeciesStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES_STATE);
        return &loadInfo;
    }
};

struct BattlePetSpeciesXAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "BattlePetAbilityID" },
            { false, FT_BYTE, "RequiredLevel" },
            { true, FT_BYTE, "SlotEnum" },
            { false, FT_SHORT, "BattlePetSpeciesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetSpeciesXAbilityMeta::Instance(), HOTFIX_SEL_BATTLE_PET_SPECIES_X_ABILITY);
        return &loadInfo;
    }
};

struct BattlePetStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "LuaName" },
            { false, FT_SHORT, "BattlePetVisualID" },
            { false, FT_SHORT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetStateMeta::Instance(), HOTFIX_SEL_BATTLE_PET_STATE);
        return &loadInfo;
    }
};

struct BattlePetVisualLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "SceneScriptFunction" },
            { true, FT_INT, "SpellVisualID" },
            { false, FT_SHORT, "CastMilliSeconds" },
            { false, FT_SHORT, "ImpactMilliSeconds" },
            { false, FT_SHORT, "SceneScriptPackageID" },
            { false, FT_BYTE, "RangeTypeEnum" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BattlePetVisualMeta::Instance(), HOTFIX_SEL_BATTLE_PET_VISUAL);
        return &loadInfo;
    }
};

struct BeamEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "BeamID" },
            { false, FT_FLOAT, "SourceMinDistance" },
            { false, FT_FLOAT, "FixedLength" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "SourceOffset" },
            { true, FT_INT, "DestOffset" },
            { true, FT_INT, "SourceAttachID" },
            { true, FT_INT, "DestAttachID" },
            { true, FT_INT, "SourcePositionerID" },
            { true, FT_INT, "DestPositionerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BeamEffectMeta::Instance(), HOTFIX_SEL_BEAM_EFFECT);
        return &loadInfo;
    }
};

struct BoneWindModifierModelLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { true, FT_INT, "BoneWindModifierID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BoneWindModifierModelMeta::Instance(), HOTFIX_SEL_BONE_WIND_MODIFIER_MODEL);
        return &loadInfo;
    }
};

struct BoneWindModifiersLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Multiplier1" },
            { false, FT_FLOAT, "Multiplier2" },
            { false, FT_FLOAT, "Multiplier3" },
            { false, FT_FLOAT, "PhaseMultiplier" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BoneWindModifiersMeta::Instance(), HOTFIX_SEL_BONE_WIND_MODIFIERS);
        return &loadInfo;
    }
};

struct BountyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_SHORT, "QuestID" },
            { false, FT_SHORT, "FactionID" },
            { true, FT_INT, "TurninPlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BountyMeta::Instance(), HOTFIX_SEL_BOUNTY);
        return &loadInfo;
    }
};

struct BountySetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "LockedQuestID" },
            { true, FT_INT, "VisiblePlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BountySetMeta::Instance(), HOTFIX_SEL_BOUNTY_SET);
        return &loadInfo;
    }
};

struct BroadcastTextLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
            { false, FT_STRING, "Text1" },
            { false, FT_SHORT, "EmoteID1" },
            { false, FT_SHORT, "EmoteID2" },
            { false, FT_SHORT, "EmoteID3" },
            { false, FT_SHORT, "EmoteDelay1" },
            { false, FT_SHORT, "EmoteDelay2" },
            { false, FT_SHORT, "EmoteDelay3" },
            { false, FT_SHORT, "EmotesID" },
            { false, FT_BYTE, "LanguageID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ConditionID" },
            { true, FT_INT, "SoundEntriesID1" },
            { true, FT_INT, "SoundEntriesID2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, BroadcastTextMeta::Instance(), HOTFIX_SEL_BROADCAST_TEXT);
        return &loadInfo;
    }
};

struct CameraEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CameraEffectMeta::Instance(), HOTFIX_SEL_CAMERA_EFFECT);
        return &loadInfo;
    }
};

struct CameraEffectEntryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_FLOAT, "Delay" },
            { false, FT_FLOAT, "Phase" },
            { false, FT_FLOAT, "Amplitude" },
            { false, FT_FLOAT, "AmplitudeB" },
            { false, FT_FLOAT, "Frequency" },
            { false, FT_FLOAT, "RadiusMin" },
            { false, FT_FLOAT, "RadiusMax" },
            { false, FT_SHORT, "AmplitudeCurveID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "EffectType" },
            { false, FT_BYTE, "DirectionType" },
            { false, FT_BYTE, "MovementType" },
            { false, FT_BYTE, "AttenuationType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CameraEffectMeta::Instance(), HOTFIX_SEL_CAMERA_EFFECT_ENTRY);
        return &loadInfo;
    }
};

struct CameraModeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "PositionOffset1" },
            { false, FT_FLOAT, "PositionOffset2" },
            { false, FT_FLOAT, "PositionOffset3" },
            { false, FT_FLOAT, "TargetOffset1" },
            { false, FT_FLOAT, "TargetOffset2" },
            { false, FT_FLOAT, "TargetOffset3" },
            { false, FT_FLOAT, "PositionSmoothing" },
            { false, FT_FLOAT, "RotationSmoothing" },
            { false, FT_FLOAT, "FieldOfView" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "LockedPositionOffsetBase" },
            { false, FT_BYTE, "LockedPositionOffsetDirection" },
            { false, FT_BYTE, "LockedTargetOffsetBase" },
            { false, FT_BYTE, "LockedTargetOffsetDirection" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CameraModeMeta::Instance(), HOTFIX_SEL_CAMERA_MODE);
        return &loadInfo;
    }
};

struct CastableRaidBuffsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CastingSpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CastableRaidBuffsMeta::Instance(), HOTFIX_SEL_CASTABLE_RAID_BUFFS);
        return &loadInfo;
    }
};

struct CelestialBodyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "BaseFileDataID" },
            { true, FT_INT, "LightMaskFileDataID" },
            { true, FT_INT, "GlowMaskFileDataID1" },
            { true, FT_INT, "GlowMaskFileDataID2" },
            { true, FT_INT, "AtmosphericMaskFileDataID" },
            { true, FT_INT, "AtmosphericModifiedFileDataID" },
            { true, FT_INT, "GlowModifiedFileDataID1" },
            { true, FT_INT, "GlowModifiedFileDataID2" },
            { false, FT_FLOAT, "ScrollURate1" },
            { false, FT_FLOAT, "ScrollURate2" },
            { false, FT_FLOAT, "ScrollVRate1" },
            { false, FT_FLOAT, "ScrollVRate2" },
            { false, FT_FLOAT, "RotateRate" },
            { false, FT_FLOAT, "GlowMaskScale1" },
            { false, FT_FLOAT, "GlowMaskScale2" },
            { false, FT_FLOAT, "AtmosphericMaskScale" },
            { false, FT_FLOAT, "Position1" },
            { false, FT_FLOAT, "Position2" },
            { false, FT_FLOAT, "Position3" },
            { false, FT_FLOAT, "BodyBaseScale" },
            { false, FT_SHORT, "SkyArrayBand" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CelestialBodyMeta::Instance(), HOTFIX_SEL_CELESTIAL_BODY);
        return &loadInfo;
    }
};

struct Cfg_CategoriesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "LocaleMask" },
            { false, FT_BYTE, "CreateCharsetMask" },
            { false, FT_BYTE, "ExistingCharsetMask" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Cfg_CategoriesMeta::Instance(), HOTFIX_SEL_CFG__CATEGORIES);
        return &loadInfo;
    }
};

struct Cfg_ConfigsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "MaxDamageReductionPctPhysical" },
            { false, FT_SHORT, "PlayerAttackSpeedBase" },
            { false, FT_BYTE, "PlayerKillingAllowed" },
            { false, FT_BYTE, "Roleplaying" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Cfg_ConfigsMeta::Instance(), HOTFIX_SEL_CFG__CONFIGS);
        return &loadInfo;
    }
};

struct Cfg_RegionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Tag" },
            { true, FT_INT, "Raidorigin" },
            { true, FT_INT, "ChallengeOrigin" },
            { false, FT_SHORT, "RegionID" },
            { false, FT_BYTE, "RegionGroup_mask" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Cfg_RegionsMeta::Instance(), HOTFIX_SEL_CFG__REGIONS);
        return &loadInfo;
    }
};

struct CharacterFaceBoneSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "BoneSetFileDataID" },
            { false, FT_BYTE, "SexID" },
            { false, FT_BYTE, "FaceVariationIndex" },
            { false, FT_BYTE, "Resolution" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharacterFaceBoneSetMeta::Instance(), HOTFIX_SEL_CHARACTER_FACE_BONE_SET);
        return &loadInfo;
    }
};

struct CharacterFacialHairStylesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Geoset1" },
            { false, FT_INT, "Geoset2" },
            { false, FT_INT, "Geoset3" },
            { false, FT_INT, "Geoset4" },
            { false, FT_INT, "Geoset5" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "SexID" },
            { false, FT_BYTE, "VariationID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharacterFacialHairStylesMeta::Instance(), HOTFIX_SEL_CHARACTER_FACIAL_HAIR_STYLES);
        return &loadInfo;
    }
};

struct CharacterLoadoutLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_LONG, "RaceMask" },
            { false, FT_BYTE, "ChrClassID" },
            { false, FT_BYTE, "Purpose" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharacterLoadoutMeta::Instance(), HOTFIX_SEL_CHARACTER_LOADOUT);
        return &loadInfo;
    }
};

struct CharacterLoadoutItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "CharacterLoadoutID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharacterLoadoutItemMeta::Instance(), HOTFIX_SEL_CHARACTER_LOADOUT_ITEM);
        return &loadInfo;
    }
};

struct CharacterServiceInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "FlowTitle" },
            { false, FT_STRING, "PopupTitle" },
            { false, FT_STRING, "PopupDescription" },
            { true, FT_INT, "BoostType" },
            { true, FT_INT, "IconFileDataID" },
            { true, FT_INT, "Priority" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "ProfessionLevel" },
            { true, FT_INT, "BoostLevel" },
            { true, FT_INT, "Expansion" },
            { true, FT_INT, "PopupUITextureKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharacterServiceInfoMeta::Instance(), HOTFIX_SEL_CHARACTER_SERVICE_INFO);
        return &loadInfo;
    }
};

struct CharBaseInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "ClassID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharBaseInfoMeta::Instance(), HOTFIX_SEL_CHAR_BASE_INFO);
        return &loadInfo;
    }
};

struct CharBaseSectionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "VariationEnum" },
            { false, FT_BYTE, "ResolutionVariationEnum" },
            { false, FT_BYTE, "LayoutResType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharBaseSectionMeta::Instance(), HOTFIX_SEL_CHAR_BASE_SECTION);
        return &loadInfo;
    }
};

struct CharComponentTextureLayoutsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Width" },
            { false, FT_SHORT, "Height" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharComponentTextureLayoutsMeta::Instance(), HOTFIX_SEL_CHAR_COMPONENT_TEXTURE_LAYOUTS);
        return &loadInfo;
    }
};

struct CharComponentTextureSectionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "OverlapSectionMask" },
            { false, FT_SHORT, "X" },
            { false, FT_SHORT, "Y" },
            { false, FT_SHORT, "Width" },
            { false, FT_SHORT, "Height" },
            { false, FT_BYTE, "CharComponentTextureLayoutID" },
            { false, FT_BYTE, "SectionType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharComponentTextureSectionsMeta::Instance(), HOTFIX_SEL_CHAR_COMPONENT_TEXTURE_SECTIONS);
        return &loadInfo;
    }
};

struct CharHairGeosetsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "HdCustomGeoFileDataID" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "SexID" },
            { false, FT_BYTE, "VariationID" },
            { false, FT_BYTE, "VariationType" },
            { false, FT_BYTE, "GeosetID" },
            { false, FT_BYTE, "GeosetType" },
            { false, FT_BYTE, "Showscalp" },
            { false, FT_BYTE, "ColorIndex" },
            { true, FT_INT, "CustomGeoFileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharHairGeosetsMeta::Instance(), HOTFIX_SEL_CHAR_HAIR_GEOSETS);
        return &loadInfo;
    }
};

struct CharSectionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "MaterialResourcesID1" },
            { true, FT_INT, "MaterialResourcesID2" },
            { true, FT_INT, "MaterialResourcesID3" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "SexID" },
            { false, FT_BYTE, "BaseSection" },
            { false, FT_BYTE, "VariationIndex" },
            { false, FT_BYTE, "ColorIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharSectionsMeta::Instance(), HOTFIX_SEL_CHAR_SECTIONS);
        return &loadInfo;
    }
};

struct CharShipmentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "TreasureID" },
            { true, FT_INT, "Duration" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "DummyItemID" },
            { true, FT_INT, "OnCompleteSpellID" },
            { false, FT_SHORT, "ContainerID" },
            { false, FT_SHORT, "GarrFollowerID" },
            { false, FT_BYTE, "MaxShipments" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharShipmentMeta::Instance(), HOTFIX_SEL_CHAR_SHIPMENT);
        return &loadInfo;
    }
};

struct CharShipmentContainerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "PendingText" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "WorkingSpellVisualID" },
            { false, FT_SHORT, "UiTextureKitID" },
            { false, FT_SHORT, "WorkingDisplayInfoID" },
            { false, FT_SHORT, "SmallDisplayInfoID" },
            { false, FT_SHORT, "MediumDisplayInfoID" },
            { false, FT_SHORT, "LargeDisplayInfoID" },
            { false, FT_SHORT, "CrossFactionID" },
            { false, FT_BYTE, "BaseCapacity" },
            { false, FT_BYTE, "GarrBuildingType" },
            { false, FT_BYTE, "GarrTypeID" },
            { false, FT_BYTE, "MediumThreshold" },
            { false, FT_BYTE, "LargeThreshold" },
            { true, FT_BYTE, "Faction" },
            { true, FT_INT, "CompleteSpellVisualID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharShipmentContainerMeta::Instance(), HOTFIX_SEL_CHAR_SHIPMENT_CONTAINER);
        return &loadInfo;
    }
};

struct CharStartOutfitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID1" },
            { true, FT_INT, "ItemID2" },
            { true, FT_INT, "ItemID3" },
            { true, FT_INT, "ItemID4" },
            { true, FT_INT, "ItemID5" },
            { true, FT_INT, "ItemID6" },
            { true, FT_INT, "ItemID7" },
            { true, FT_INT, "ItemID8" },
            { true, FT_INT, "ItemID9" },
            { true, FT_INT, "ItemID10" },
            { true, FT_INT, "ItemID11" },
            { true, FT_INT, "ItemID12" },
            { true, FT_INT, "ItemID13" },
            { true, FT_INT, "ItemID14" },
            { true, FT_INT, "ItemID15" },
            { true, FT_INT, "ItemID16" },
            { true, FT_INT, "ItemID17" },
            { true, FT_INT, "ItemID18" },
            { true, FT_INT, "ItemID19" },
            { true, FT_INT, "ItemID20" },
            { true, FT_INT, "ItemID21" },
            { true, FT_INT, "ItemID22" },
            { true, FT_INT, "ItemID23" },
            { true, FT_INT, "ItemID24" },
            { true, FT_INT, "PetDisplayID" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "SexID" },
            { false, FT_BYTE, "OutfitID" },
            { false, FT_BYTE, "PetFamilyID" },
            { false, FT_BYTE, "RaceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharStartOutfitMeta::Instance(), HOTFIX_SEL_CHAR_START_OUTFIT);
        return &loadInfo;
    }
};

struct CharTitlesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Name1" },
            { true, FT_SHORT, "MaskID" },
            { true, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CharTitlesMeta::Instance(), HOTFIX_SEL_CHAR_TITLES);
        return &loadInfo;
    }
};

struct ChatChannelsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Shortcut" },
            { true, FT_INT, "Flags" },
            { false, FT_BYTE, "FactionGroup" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChatChannelsMeta::Instance(), HOTFIX_SEL_CHAT_CHANNELS);
        return &loadInfo;
    }
};

struct ChatProfanityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
            { false, FT_BYTE, "Language" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChatProfanityMeta::Instance(), HOTFIX_SEL_CHAT_PROFANITY);
        return &loadInfo;
    }
};

struct ChrClassesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "PetNameToken" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "NameFemale" },
            { false, FT_STRING, "NameMale" },
            { false, FT_STRING, "Filename" },
            { true, FT_INT, "CreateScreenFileDataID" },
            { true, FT_INT, "SelectScreenFileDataID" },
            { true, FT_INT, "LowResScreenFileDataID" },
            { true, FT_INT, "IconFileDataID" },
            { true, FT_INT, "StartingLevel" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "CinematicSequenceID" },
            { false, FT_SHORT, "DefaultSpec" },
            { false, FT_BYTE, "DisplayPower" },
            { false, FT_BYTE, "SpellClassSet" },
            { false, FT_BYTE, "AttackPowerPerStrength" },
            { false, FT_BYTE, "AttackPowerPerAgility" },
            { false, FT_BYTE, "RangedAttackPowerPerAgility" },
            { false, FT_BYTE, "PrimaryStatPriority" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES);
        return &loadInfo;
    }
};

struct ChrClassesXPowerTypesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "PowerType" },
            { false, FT_BYTE, "ClassID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassesXPowerTypesMeta::Instance(), HOTFIX_SEL_CHR_CLASSES_X_POWER_TYPES);
        return &loadInfo;
    }
};

struct ChrClassRaceSexLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "Sex" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "SoundID" },
            { true, FT_INT, "VoiceSoundFilterID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassRaceSexMeta::Instance(), HOTFIX_SEL_CHR_CLASS_RACE_SEX);
        return &loadInfo;
    }
};

struct ChrClassTitleLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "NameMale" },
            { false, FT_STRING, "NameFemale" },
            { false, FT_BYTE, "ChrClassID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassTitleMeta::Instance(), HOTFIX_SEL_CHR_CLASS_TITLE);
        return &loadInfo;
    }
};

struct ChrClassUIDisplayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "ChrClassesID" },
            { true, FT_INT, "AdvGuidePlayerConditionID" },
            { true, FT_INT, "SplashPlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassUIDisplayMeta::Instance(), HOTFIX_SEL_CHR_CLASS_U_I_DISPLAY);
        return &loadInfo;
    }
};

struct ChrClassVillainLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "ChrClassID" },
            { false, FT_BYTE, "Gender" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrClassVillainMeta::Instance(), HOTFIX_SEL_CHR_CLASS_VILLAIN);
        return &loadInfo;
    }
};

struct ChrCustomizationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "Sex" },
            { true, FT_INT, "BaseSection" },
            { true, FT_INT, "UiCustomizationType" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "ComponentSection1" },
            { true, FT_INT, "ComponentSection2" },
            { true, FT_INT, "ComponentSection3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrCustomizationMeta::Instance(), HOTFIX_SEL_CHR_CUSTOMIZATION);
        return &loadInfo;
    }
};

struct ChrRacesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "ClientPrefix" },
            { false, FT_STRING, "ClientFileString" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "NameFemale" },
            { false, FT_STRING, "NameLowercase" },
            { false, FT_STRING, "NameFemale_lowercase" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "MaleDisplayID" },
            { true, FT_INT, "FemaleDisplayID" },
            { true, FT_INT, "CreateScreenFileDataID" },
            { true, FT_INT, "SelectScreenFileDataID" },
            { false, FT_FLOAT, "MaleCustomizeOffset1" },
            { false, FT_FLOAT, "MaleCustomizeOffset2" },
            { false, FT_FLOAT, "MaleCustomizeOffset3" },
            { false, FT_FLOAT, "FemaleCustomizeOffset1" },
            { false, FT_FLOAT, "FemaleCustomizeOffset2" },
            { false, FT_FLOAT, "FemaleCustomizeOffset3" },
            { true, FT_INT, "LowResScreenFileDataID" },
            { true, FT_INT, "StartingLevel" },
            { true, FT_INT, "UiDisplayOrder" },
            { false, FT_SHORT, "FactionID" },
            { false, FT_SHORT, "ResSicknessSpellID" },
            { false, FT_SHORT, "SplashSoundID" },
            { false, FT_SHORT, "CinematicSequenceID" },
            { false, FT_BYTE, "BaseLanguage" },
            { false, FT_BYTE, "CreatureType" },
            { false, FT_BYTE, "Alliance" },
            { false, FT_BYTE, "RaceRelated" },
            { false, FT_BYTE, "UnalteredVisualRaceID" },
            { false, FT_BYTE, "CharComponentTextureLayoutID" },
            { false, FT_BYTE, "DefaultClassID" },
            { false, FT_BYTE, "NeutralRaceID" },
            { false, FT_BYTE, "DisplayRaceID" },
            { false, FT_BYTE, "CharComponentTexLayoutHiResID" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "HighResMaleDisplayID" },
            { true, FT_INT, "HighResFemaleDisplayID" },
            { true, FT_INT, "HeritageArmorAchievementID" },
            { true, FT_INT, "MaleSkeletonFileDataID" },
            { true, FT_INT, "FemaleSkeletonFileDataID" },
            { true, FT_INT, "AlteredFormStartVisualKitID1" },
            { true, FT_INT, "AlteredFormStartVisualKitID2" },
            { true, FT_INT, "AlteredFormStartVisualKitID3" },
            { true, FT_INT, "AlteredFormFinishVisualKitID1" },
            { true, FT_INT, "AlteredFormFinishVisualKitID2" },
            { true, FT_INT, "AlteredFormFinishVisualKitID3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrRacesMeta::Instance(), HOTFIX_SEL_CHR_RACES);
        return &loadInfo;
    }
};

struct ChrSpecializationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "FemaleName" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "MasterySpellID1" },
            { true, FT_INT, "MasterySpellID2" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "PetTalentType" },
            { false, FT_BYTE, "Role" },
            { false, FT_BYTE, "PrimaryStatPriority" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellIconFileID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "AnimReplacements" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrSpecializationMeta::Instance(), HOTFIX_SEL_CHR_SPECIALIZATION);
        return &loadInfo;
    }
};

struct ChrUpgradeBucketLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "ChrSpecializationID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrUpgradeBucketMeta::Instance(), HOTFIX_SEL_CHR_UPGRADE_BUCKET);
        return &loadInfo;
    }
};

struct ChrUpgradeBucketSpellLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrUpgradeBucketSpellMeta::Instance(), HOTFIX_SEL_CHR_UPGRADE_BUCKET_SPELL);
        return &loadInfo;
    }
};

struct ChrUpgradeTierLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "DisplayName" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "NumTalents" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ChrUpgradeTierMeta::Instance(), HOTFIX_SEL_CHR_UPGRADE_TIER);
        return &loadInfo;
    }
};

struct CinematicCameraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundID" },
            { false, FT_FLOAT, "Origin1" },
            { false, FT_FLOAT, "Origin2" },
            { false, FT_FLOAT, "Origin3" },
            { false, FT_FLOAT, "OriginFacing" },
            { true, FT_INT, "FileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CinematicCameraMeta::Instance(), HOTFIX_SEL_CINEMATIC_CAMERA);
        return &loadInfo;
    }
};

struct CinematicSequencesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundID" },
            { false, FT_SHORT, "Camera1" },
            { false, FT_SHORT, "Camera2" },
            { false, FT_SHORT, "Camera3" },
            { false, FT_SHORT, "Camera4" },
            { false, FT_SHORT, "Camera5" },
            { false, FT_SHORT, "Camera6" },
            { false, FT_SHORT, "Camera7" },
            { false, FT_SHORT, "Camera8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CinematicSequencesMeta::Instance(), HOTFIX_SEL_CINEMATIC_SEQUENCES);
        return &loadInfo;
    }
};

struct CloakDampeningLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Angle1" },
            { false, FT_FLOAT, "Angle2" },
            { false, FT_FLOAT, "Angle3" },
            { false, FT_FLOAT, "Angle4" },
            { false, FT_FLOAT, "Angle5" },
            { false, FT_FLOAT, "Dampening1" },
            { false, FT_FLOAT, "Dampening2" },
            { false, FT_FLOAT, "Dampening3" },
            { false, FT_FLOAT, "Dampening4" },
            { false, FT_FLOAT, "Dampening5" },
            { false, FT_FLOAT, "TailAngle1" },
            { false, FT_FLOAT, "TailAngle2" },
            { false, FT_FLOAT, "TailDampening1" },
            { false, FT_FLOAT, "TailDampening2" },
            { false, FT_FLOAT, "TabardAngle" },
            { false, FT_FLOAT, "TabardDampening" },
            { false, FT_FLOAT, "ExpectedWeaponSize" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CloakDampeningMeta::Instance(), HOTFIX_SEL_CLOAK_DAMPENING);
        return &loadInfo;
    }
};

struct CombatConditionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "WorldStateExpressionID" },
            { false, FT_SHORT, "SelfConditionID" },
            { false, FT_SHORT, "TargetConditionID" },
            { false, FT_SHORT, "FriendConditionID1" },
            { false, FT_SHORT, "FriendConditionID2" },
            { false, FT_SHORT, "EnemyConditionID1" },
            { false, FT_SHORT, "EnemyConditionID2" },
            { false, FT_BYTE, "FriendConditionOp1" },
            { false, FT_BYTE, "FriendConditionOp2" },
            { false, FT_BYTE, "FriendConditionCount1" },
            { false, FT_BYTE, "FriendConditionCount2" },
            { false, FT_BYTE, "FriendConditionLogic" },
            { false, FT_BYTE, "EnemyConditionOp1" },
            { false, FT_BYTE, "EnemyConditionOp2" },
            { false, FT_BYTE, "EnemyConditionCount1" },
            { false, FT_BYTE, "EnemyConditionCount2" },
            { false, FT_BYTE, "EnemyConditionLogic" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CombatConditionMeta::Instance(), HOTFIX_SEL_COMBAT_CONDITION);
        return &loadInfo;
    }
};

struct CommentatorStartLocationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_FLOAT, "Pos3" },
            { true, FT_INT, "MapID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CommentatorStartLocationMeta::Instance(), HOTFIX_SEL_COMMENTATOR_START_LOCATION);
        return &loadInfo;
    }
};

struct CommentatorTrackedCooldownLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Priority" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CommentatorTrackedCooldownMeta::Instance(), HOTFIX_SEL_COMMENTATOR_TRACKED_COOLDOWN);
        return &loadInfo;
    }
};

struct ComponentModelFileDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "GenderIndex" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "PositionIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ComponentModelFileDataMeta::Instance(), HOTFIX_SEL_COMPONENT_MODEL_FILE_DATA);
        return &loadInfo;
    }
};

struct ComponentTextureFileDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "GenderIndex" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "RaceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ComponentTextureFileDataMeta::Instance(), HOTFIX_SEL_COMPONENT_TEXTURE_FILE_DATA);
        return &loadInfo;
    }
};

struct ConfigurationWarningLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Warning" },
            { true, FT_INT, "Type" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ConfigurationWarningMeta::Instance(), HOTFIX_SEL_CONFIGURATION_WARNING);
        return &loadInfo;
    }
};

struct ContributionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "ManagedWorldStateInputID" },
            { true, FT_INT, "UiTextureAtlasMemberID1" },
            { true, FT_INT, "UiTextureAtlasMemberID2" },
            { true, FT_INT, "UiTextureAtlasMemberID3" },
            { true, FT_INT, "UiTextureAtlasMemberID4" },
            { true, FT_INT, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ContributionMeta::Instance(), HOTFIX_SEL_CONTRIBUTION);
        return &loadInfo;
    }
};

struct ConversationLineLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "BroadcastTextID" },
            { true, FT_INT, "SpellVisualKitID" },
            { false, FT_INT, "AdditionalDuration" },
            { true, FT_SHORT, "NextConversationLineID" },
            { false, FT_SHORT, "AnimKitID" },
            { false, FT_BYTE, "SpeechType" },
            { false, FT_BYTE, "StartAnimation" },
            { false, FT_BYTE, "EndAnimation" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ConversationLineMeta::Instance(), HOTFIX_SEL_CONVERSATION_LINE);
        return &loadInfo;
    }
};

struct CreatureLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "NameAlt" },
            { false, FT_STRING, "Title" },
            { false, FT_STRING, "TitleAlt" },
            { true, FT_INT, "AlwaysItem1" },
            { true, FT_INT, "AlwaysItem2" },
            { true, FT_INT, "AlwaysItem3" },
            { true, FT_INT, "MountCreatureID" },
            { true, FT_INT, "DisplayID1" },
            { true, FT_INT, "DisplayID2" },
            { true, FT_INT, "DisplayID3" },
            { true, FT_INT, "DisplayID4" },
            { false, FT_FLOAT, "DisplayProbability1" },
            { false, FT_FLOAT, "DisplayProbability2" },
            { false, FT_FLOAT, "DisplayProbability3" },
            { false, FT_FLOAT, "DisplayProbability4" },
            { false, FT_BYTE, "CreatureType" },
            { false, FT_BYTE, "CreatureFamily" },
            { false, FT_BYTE, "Classification" },
            { false, FT_BYTE, "StartAnimState" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureMeta::Instance(), HOTFIX_SEL_CREATURE);
        return &loadInfo;
    }
};

struct CreatureDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Flags1" },
            { false, FT_INT, "Flags2" },
            { false, FT_INT, "Flags3" },
            { false, FT_INT, "Flags4" },
            { false, FT_INT, "Flags5" },
            { false, FT_INT, "Flags6" },
            { false, FT_INT, "Flags7" },
            { true, FT_SHORT, "FactionID" },
            { true, FT_BYTE, "ExpansionID" },
            { true, FT_BYTE, "MinLevel" },
            { true, FT_BYTE, "MaxLevel" },
            { true, FT_INT, "CreatureID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDifficultyMeta::Instance(), HOTFIX_SEL_CREATURE_DIFFICULTY);
        return &loadInfo;
    }
};

struct CreatureDisplayInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "CreatureModelScale" },
            { false, FT_SHORT, "ModelID" },
            { false, FT_SHORT, "NPCSoundID" },
            { false, FT_BYTE, "SizeClass" },
            { false, FT_BYTE, "Flags" },
            { true, FT_BYTE, "Gender" },
            { true, FT_INT, "ExtendedDisplayInfoID" },
            { true, FT_INT, "PortraitTextureFileDataID" },
            { false, FT_BYTE, "CreatureModelAlpha" },
            { false, FT_SHORT, "SoundID" },
            { false, FT_FLOAT, "PlayerOverrideScale" },
            { true, FT_INT, "PortraitCreatureDisplayInfoID" },
            { false, FT_BYTE, "BloodID" },
            { false, FT_SHORT, "ParticleColorID" },
            { false, FT_INT, "DissolveEffectID" },
            { false, FT_SHORT, "ObjectEffectPackageID" },
            { false, FT_SHORT, "AnimReplacementSetID" },
            { true, FT_BYTE, "UnarmedWeaponType" },
            { true, FT_INT, "StateSpellVisualKitID" },
            { false, FT_FLOAT, "PetInstanceScale" },
            { true, FT_INT, "MountPoofSpellVisualKitID" },
            { true, FT_INT, "TextureVariationFileDataID1" },
            { true, FT_INT, "TextureVariationFileDataID2" },
            { true, FT_INT, "TextureVariationFileDataID3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO);
        return &loadInfo;
    }
};

struct CreatureDisplayInfoCondLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_LONG, "RaceMask" },
            { false, FT_INT, "CustomOption0Mask1" },
            { false, FT_INT, "CustomOption0Mask2" },
            { true, FT_INT, "CustomOption1Mask1" },
            { true, FT_INT, "CustomOption1Mask2" },
            { true, FT_INT, "CustomOption2Mask1" },
            { true, FT_INT, "CustomOption2Mask2" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "Gender" },
            { true, FT_INT, "ClassMask" },
            { true, FT_INT, "SkinColorMask" },
            { true, FT_INT, "HairColorMask" },
            { true, FT_INT, "HairStyleMask" },
            { true, FT_INT, "FaceStyleMask" },
            { true, FT_INT, "FacialHairStyleMask" },
            { true, FT_INT, "CreatureModelDataID" },
            { true, FT_INT, "TextureVariationFileDataID1" },
            { true, FT_INT, "TextureVariationFileDataID2" },
            { true, FT_INT, "TextureVariationFileDataID3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoCondMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_COND);
        return &loadInfo;
    }
};

struct CreatureDisplayInfoEvtLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Fourcc" },
            { true, FT_INT, "SpellVisualKitID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoEvtMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_EVT);
        return &loadInfo;
    }
};

struct CreatureDisplayInfoExtraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "BakeMaterialResourcesID" },
            { true, FT_INT, "HDBakeMaterialResourcesID" },
            { false, FT_BYTE, "DisplayRaceID" },
            { false, FT_BYTE, "DisplaySexID" },
            { false, FT_BYTE, "DisplayClassID" },
            { false, FT_BYTE, "SkinID" },
            { false, FT_BYTE, "FaceID" },
            { false, FT_BYTE, "HairStyleID" },
            { false, FT_BYTE, "HairColorID" },
            { false, FT_BYTE, "FacialHairID" },
            { false, FT_BYTE, "CustomDisplayOption1" },
            { false, FT_BYTE, "CustomDisplayOption2" },
            { false, FT_BYTE, "CustomDisplayOption3" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoExtraMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_EXTRA);
        return &loadInfo;
    }
};

struct CreatureDisplayInfoTrnLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "DstCreatureDisplayInfoID" },
            { false, FT_FLOAT, "MaxTime" },
            { true, FT_INT, "DissolveEffectID" },
            { true, FT_INT, "StartVisualKitID" },
            { true, FT_INT, "FinishVisualKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDisplayInfoTrnMeta::Instance(), HOTFIX_SEL_CREATURE_DISPLAY_INFO_TRN);
        return &loadInfo;
    }
};

struct CreatureDispXUiCameraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CreatureDisplayInfoID" },
            { false, FT_SHORT, "UiCameraID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureDispXUiCameraMeta::Instance(), HOTFIX_SEL_CREATURE_DISP_X_UI_CAMERA);
        return &loadInfo;
    }
};

struct CreatureFamilyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "MinScale" },
            { false, FT_FLOAT, "MaxScale" },
            { true, FT_INT, "IconFileID" },
            { false, FT_SHORT, "SkillLine1" },
            { false, FT_SHORT, "SkillLine2" },
            { false, FT_SHORT, "PetFoodMask" },
            { false, FT_BYTE, "MinScaleLevel" },
            { false, FT_BYTE, "MaxScaleLevel" },
            { false, FT_BYTE, "PetTalentType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureFamilyMeta::Instance(), HOTFIX_SEL_CREATURE_FAMILY);
        return &loadInfo;
    }
};

struct CreatureImmunitiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Mechanic1" },
            { true, FT_INT, "Mechanic2" },
            { false, FT_BYTE, "School" },
            { false, FT_BYTE, "MechanicsAllowed" },
            { false, FT_BYTE, "EffectsAllowed" },
            { false, FT_BYTE, "StatesAllowed" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "DispelType" },
            { true, FT_INT, "Effect1" },
            { true, FT_INT, "Effect2" },
            { true, FT_INT, "Effect3" },
            { true, FT_INT, "Effect4" },
            { true, FT_INT, "Effect5" },
            { true, FT_INT, "Effect6" },
            { true, FT_INT, "Effect7" },
            { true, FT_INT, "Effect8" },
            { true, FT_INT, "Effect9" },
            { true, FT_INT, "State1" },
            { true, FT_INT, "State2" },
            { true, FT_INT, "State3" },
            { true, FT_INT, "State4" },
            { true, FT_INT, "State5" },
            { true, FT_INT, "State6" },
            { true, FT_INT, "State7" },
            { true, FT_INT, "State8" },
            { true, FT_INT, "State9" },
            { true, FT_INT, "State10" },
            { true, FT_INT, "State11" },
            { true, FT_INT, "State12" },
            { true, FT_INT, "State13" },
            { true, FT_INT, "State14" },
            { true, FT_INT, "State15" },
            { true, FT_INT, "State16" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureImmunitiesMeta::Instance(), HOTFIX_SEL_CREATURE_IMMUNITIES);
        return &loadInfo;
    }
};

struct CreatureModelDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ModelScale" },
            { false, FT_FLOAT, "FootprintTextureLength" },
            { false, FT_FLOAT, "FootprintTextureWidth" },
            { false, FT_FLOAT, "FootprintParticleScale" },
            { false, FT_FLOAT, "CollisionWidth" },
            { false, FT_FLOAT, "CollisionHeight" },
            { false, FT_FLOAT, "MountHeight" },
            { false, FT_FLOAT, "GeoBox1" },
            { false, FT_FLOAT, "GeoBox2" },
            { false, FT_FLOAT, "GeoBox3" },
            { false, FT_FLOAT, "GeoBox4" },
            { false, FT_FLOAT, "GeoBox5" },
            { false, FT_FLOAT, "GeoBox6" },
            { false, FT_FLOAT, "WorldEffectScale" },
            { false, FT_FLOAT, "AttachedEffectScale" },
            { false, FT_FLOAT, "MissileCollisionRadius" },
            { false, FT_FLOAT, "MissileCollisionPush" },
            { false, FT_FLOAT, "MissileCollisionRaise" },
            { false, FT_FLOAT, "OverrideLootEffectScale" },
            { false, FT_FLOAT, "OverrideNameScale" },
            { false, FT_FLOAT, "OverrideSelectionRadius" },
            { false, FT_FLOAT, "TamedPetBaseScale" },
            { false, FT_FLOAT, "HoverHeight" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "FileDataID" },
            { true, FT_INT, "SizeClass" },
            { true, FT_INT, "BloodID" },
            { true, FT_INT, "FootprintTextureID" },
            { true, FT_INT, "FoleyMaterialID" },
            { true, FT_INT, "FootstepCameraEffectID" },
            { true, FT_INT, "DeathThudCameraEffectID" },
            { true, FT_INT, "SoundID" },
            { true, FT_INT, "CreatureGeosetDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureModelDataMeta::Instance(), HOTFIX_SEL_CREATURE_MODEL_DATA);
        return &loadInfo;
    }
};

struct CreatureMovementInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "SmoothFacingChaseRate" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureMovementInfoMeta::Instance(), HOTFIX_SEL_CREATURE_MOVEMENT_INFO);
        return &loadInfo;
    }
};

struct CreatureSoundDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "FidgetDelaySecondsMin" },
            { false, FT_FLOAT, "FidgetDelaySecondsMax" },
            { false, FT_BYTE, "CreatureImpactType" },
            { true, FT_INT, "SoundExertionID" },
            { true, FT_INT, "SoundExertionCriticalID" },
            { true, FT_INT, "SoundInjuryID" },
            { true, FT_INT, "SoundInjuryCriticalID" },
            { true, FT_INT, "SoundInjuryCrushingBlowID" },
            { true, FT_INT, "SoundDeathID" },
            { true, FT_INT, "SoundStunID" },
            { true, FT_INT, "SoundStandID" },
            { true, FT_INT, "SoundFootstepID" },
            { true, FT_INT, "SoundAggroID" },
            { true, FT_INT, "SoundWingFlapID" },
            { true, FT_INT, "SoundWingGlideID" },
            { true, FT_INT, "SoundAlertID" },
            { true, FT_INT, "NPCSoundID" },
            { true, FT_INT, "LoopSoundID" },
            { true, FT_INT, "SoundJumpStartID" },
            { true, FT_INT, "SoundJumpEndID" },
            { true, FT_INT, "SoundPetAttackID" },
            { true, FT_INT, "SoundPetOrderID" },
            { true, FT_INT, "SoundPetDismissID" },
            { true, FT_INT, "BirthSoundID" },
            { true, FT_INT, "SpellCastDirectedSoundID" },
            { true, FT_INT, "SubmergeSoundID" },
            { true, FT_INT, "SubmergedSoundID" },
            { true, FT_INT, "CreatureSoundDataIDPet" },
            { true, FT_INT, "WindupSoundID" },
            { true, FT_INT, "WindupCriticalSoundID" },
            { true, FT_INT, "ChargeSoundID" },
            { true, FT_INT, "ChargeCriticalSoundID" },
            { true, FT_INT, "BattleShoutSoundID" },
            { true, FT_INT, "BattleShoutCriticalSoundID" },
            { true, FT_INT, "TauntSoundID" },
            { true, FT_INT, "SoundFidget1" },
            { true, FT_INT, "SoundFidget2" },
            { true, FT_INT, "SoundFidget3" },
            { true, FT_INT, "SoundFidget4" },
            { true, FT_INT, "SoundFidget5" },
            { true, FT_INT, "CustomAttack1" },
            { true, FT_INT, "CustomAttack2" },
            { true, FT_INT, "CustomAttack3" },
            { true, FT_INT, "CustomAttack4" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureSoundDataMeta::Instance(), HOTFIX_SEL_CREATURE_SOUND_DATA);
        return &loadInfo;
    }
};

struct CreatureTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureTypeMeta::Instance(), HOTFIX_SEL_CREATURE_TYPE);
        return &loadInfo;
    }
};

struct CreatureXContributionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ContributionID" },
            { false, FT_INT, "CreatureId" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CreatureXContributionMeta::Instance(), HOTFIX_SEL_CREATURE_X_CONTRIBUTION);
        return &loadInfo;
    }
};

struct CriteriaLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Asset" },
            { true, FT_INT, "StartAsset" },
            { false, FT_INT, "FailAsset" },
            { true, FT_INT, "ModifierTreeId" },
            { false, FT_SHORT, "StartTimer" },
            { true, FT_SHORT, "EligibilityWorldStateId" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "StartEvent" },
            { false, FT_BYTE, "FailEvent" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "EligibilityWorldStateValue" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaMeta::Instance(), HOTFIX_SEL_CRITERIA);
        return &loadInfo;
    }
};

struct CriteriaTreeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "Amount" },
            { true, FT_SHORT, "Flags" },
            { true, FT_BYTE, "Operator" },
            { true, FT_INT, "CriteriaID" },
            { true, FT_INT, "Parent" },
            { true, FT_INT, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaTreeMeta::Instance(), HOTFIX_SEL_CRITERIA_TREE);
        return &loadInfo;
    }
};

struct CriteriaTreeXEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "WorldEffectID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CriteriaTreeXEffectMeta::Instance(), HOTFIX_SEL_CRITERIA_TREE_X_EFFECT);
        return &loadInfo;
    }
};

struct CurrencyCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "ExpansionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CurrencyCategoryMeta::Instance(), HOTFIX_SEL_CURRENCY_CATEGORY);
        return &loadInfo;
    }
};

struct CurrencyTypesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "MaxQty" },
            { true, FT_INT, "MaxEarnablePerWeek" },
            { true, FT_INT, "Flags" },
            { false, FT_BYTE, "CategoryID" },
            { false, FT_BYTE, "SpellCategory" },
            { false, FT_BYTE, "Quality" },
            { true, FT_INT, "InventoryIconFileID" },
            { true, FT_INT, "SpellWeight" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CurrencyTypesMeta::Instance(), HOTFIX_SEL_CURRENCY_TYPES);
        return &loadInfo;
    }
};

struct CurveLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CurveMeta::Instance(), HOTFIX_SEL_CURVE);
        return &loadInfo;
    }
};

struct CurvePointLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "PosX" },
            { false, FT_FLOAT, "PosY" },
            { false, FT_SHORT, "CurveID" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, CurvePointMeta::Instance(), HOTFIX_SEL_CURVE_POINT);
        return &loadInfo;
    }
};

struct DeathThudLookupsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "SizeClass" },
            { false, FT_BYTE, "TerrainTypeSoundID" },
            { true, FT_INT, "SoundEntryID" },
            { true, FT_INT, "SoundEntryIDWater" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DeathThudLookupsMeta::Instance(), HOTFIX_SEL_DEATH_THUD_LOOKUPS);
        return &loadInfo;
    }
};

struct DecalPropertiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_FLOAT, "InnerRadius" },
            { false, FT_FLOAT, "OuterRadius" },
            { false, FT_FLOAT, "Rim" },
            { false, FT_FLOAT, "Gain" },
            { false, FT_FLOAT, "ModX" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_FLOAT, "FadeIn" },
            { false, FT_FLOAT, "FadeOut" },
            { false, FT_BYTE, "Priority" },
            { false, FT_BYTE, "BlendMode" },
            { true, FT_INT, "TopTextureBlendSetID" },
            { true, FT_INT, "BotTextureBlendSetID" },
            { true, FT_INT, "GameFlags" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "CasterDecalPropertiesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DecalPropertiesMeta::Instance(), HOTFIX_SEL_DECAL_PROPERTIES);
        return &loadInfo;
    }
};

struct DeclinedWordLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Word" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DeclinedWordMeta::Instance(), HOTFIX_SEL_DECLINED_WORD);
        return &loadInfo;
    }
};

struct DeclinedWordCasesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "DeclinedWord" },
            { false, FT_BYTE, "CaseIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DeclinedWordCasesMeta::Instance(), HOTFIX_SEL_DECLINED_WORD_CASES);
        return &loadInfo;
    }
};

struct DestructibleModelDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "State0Wmo" },
            { false, FT_SHORT, "State1Wmo" },
            { false, FT_SHORT, "State2Wmo" },
            { false, FT_SHORT, "State3Wmo" },
            { false, FT_SHORT, "HealEffectSpeed" },
            { false, FT_BYTE, "State0ImpactEffectDoodadSet" },
            { false, FT_BYTE, "State0AmbientDoodadSet" },
            { false, FT_BYTE, "State0NameSet" },
            { false, FT_BYTE, "State1DestructionDoodadSet" },
            { false, FT_BYTE, "State1ImpactEffectDoodadSet" },
            { false, FT_BYTE, "State1AmbientDoodadSet" },
            { false, FT_BYTE, "State1NameSet" },
            { false, FT_BYTE, "State2DestructionDoodadSet" },
            { false, FT_BYTE, "State2ImpactEffectDoodadSet" },
            { false, FT_BYTE, "State2AmbientDoodadSet" },
            { false, FT_BYTE, "State2NameSet" },
            { false, FT_BYTE, "State3InitDoodadSet" },
            { false, FT_BYTE, "State3AmbientDoodadSet" },
            { false, FT_BYTE, "State3NameSet" },
            { false, FT_BYTE, "EjectDirection" },
            { false, FT_BYTE, "DoNotHighlight" },
            { false, FT_BYTE, "HealEffect" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DestructibleModelDataMeta::Instance(), HOTFIX_SEL_DESTRUCTIBLE_MODEL_DATA);
        return &loadInfo;
    }
};

struct DeviceBlacklistLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "VendorID" },
            { false, FT_SHORT, "DeviceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DeviceBlacklistMeta::Instance(), HOTFIX_SEL_DEVICE_BLACKLIST);
        return &loadInfo;
    }
};

struct DeviceDefaultSettingsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "VendorID" },
            { false, FT_SHORT, "DeviceID" },
            { false, FT_BYTE, "DefaultSetting" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DeviceDefaultSettingsMeta::Instance(), HOTFIX_SEL_DEVICE_DEFAULT_SETTINGS);
        return &loadInfo;
    }
};

struct DifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "GroupSizeHealthCurveID" },
            { false, FT_SHORT, "GroupSizeDmgCurveID" },
            { false, FT_SHORT, "GroupSizeSpellPointsCurveID" },
            { false, FT_BYTE, "FallbackDifficultyID" },
            { false, FT_BYTE, "InstanceType" },
            { false, FT_BYTE, "MinPlayers" },
            { false, FT_BYTE, "MaxPlayers" },
            { true, FT_BYTE, "OldEnumValue" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "ToggleDifficultyID" },
            { false, FT_BYTE, "ItemContext" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DifficultyMeta::Instance(), HOTFIX_SEL_DIFFICULTY);
        return &loadInfo;
    }
};

struct DissolveEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Ramp" },
            { false, FT_FLOAT, "StartValue" },
            { false, FT_FLOAT, "EndValue" },
            { false, FT_FLOAT, "FadeInTime" },
            { false, FT_FLOAT, "FadeOutTime" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_FLOAT, "FresnelIntensity" },
            { false, FT_BYTE, "AttachID" },
            { false, FT_BYTE, "ProjectionType" },
            { true, FT_INT, "TextureBlendSetID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "CurveID" },
            { true, FT_INT, "Priority" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DissolveEffectMeta::Instance(), HOTFIX_SEL_DISSOLVE_EFFECT);
        return &loadInfo;
    }
};

struct DriverBlacklistLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "DriverVersionHi" },
            { true, FT_INT, "DriverVersionLow" },
            { false, FT_SHORT, "VendorID" },
            { false, FT_BYTE, "DeviceID" },
            { false, FT_BYTE, "OsVersion" },
            { false, FT_BYTE, "OsBits" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DriverBlacklistMeta::Instance(), HOTFIX_SEL_DRIVER_BLACKLIST);
        return &loadInfo;
    }
};

struct DungeonEncounterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { true, FT_INT, "CreatureDisplayID" },
            { false, FT_SHORT, "MapID" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "Bit" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "OrderIndex" },
            { true, FT_INT, "SpellIconFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DungeonEncounterMeta::Instance(), HOTFIX_SEL_DUNGEON_ENCOUNTER);
        return &loadInfo;
    }
};

struct DungeonMapLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "Min1" },
            { false, FT_FLOAT, "Min2" },
            { false, FT_FLOAT, "Max1" },
            { false, FT_FLOAT, "Max2" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "ParentWorldMapID" },
            { false, FT_BYTE, "FloorIndex" },
            { false, FT_BYTE, "RelativeHeightIndex" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DungeonMapMeta::Instance(), HOTFIX_SEL_DUNGEON_MAP);
        return &loadInfo;
    }
};

struct DungeonMapChunkLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "MinZ" },
            { true, FT_INT, "DoodadPlacementID" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "WmoGroupID" },
            { false, FT_SHORT, "DungeonMapID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DungeonMapChunkMeta::Instance(), HOTFIX_SEL_DUNGEON_MAP_CHUNK);
        return &loadInfo;
    }
};

struct DurabilityCostsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "WeaponSubClassCost1" },
            { false, FT_SHORT, "WeaponSubClassCost2" },
            { false, FT_SHORT, "WeaponSubClassCost3" },
            { false, FT_SHORT, "WeaponSubClassCost4" },
            { false, FT_SHORT, "WeaponSubClassCost5" },
            { false, FT_SHORT, "WeaponSubClassCost6" },
            { false, FT_SHORT, "WeaponSubClassCost7" },
            { false, FT_SHORT, "WeaponSubClassCost8" },
            { false, FT_SHORT, "WeaponSubClassCost9" },
            { false, FT_SHORT, "WeaponSubClassCost10" },
            { false, FT_SHORT, "WeaponSubClassCost11" },
            { false, FT_SHORT, "WeaponSubClassCost12" },
            { false, FT_SHORT, "WeaponSubClassCost13" },
            { false, FT_SHORT, "WeaponSubClassCost14" },
            { false, FT_SHORT, "WeaponSubClassCost15" },
            { false, FT_SHORT, "WeaponSubClassCost16" },
            { false, FT_SHORT, "WeaponSubClassCost17" },
            { false, FT_SHORT, "WeaponSubClassCost18" },
            { false, FT_SHORT, "WeaponSubClassCost19" },
            { false, FT_SHORT, "WeaponSubClassCost20" },
            { false, FT_SHORT, "WeaponSubClassCost21" },
            { false, FT_SHORT, "ArmorSubClassCost1" },
            { false, FT_SHORT, "ArmorSubClassCost2" },
            { false, FT_SHORT, "ArmorSubClassCost3" },
            { false, FT_SHORT, "ArmorSubClassCost4" },
            { false, FT_SHORT, "ArmorSubClassCost5" },
            { false, FT_SHORT, "ArmorSubClassCost6" },
            { false, FT_SHORT, "ArmorSubClassCost7" },
            { false, FT_SHORT, "ArmorSubClassCost8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DurabilityCostsMeta::Instance(), HOTFIX_SEL_DURABILITY_COSTS);
        return &loadInfo;
    }
};

struct DurabilityQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Data" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, DurabilityQualityMeta::Instance(), HOTFIX_SEL_DURABILITY_QUALITY);
        return &loadInfo;
    }
};

struct EdgeGlowEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_FLOAT, "FadeIn" },
            { false, FT_FLOAT, "FadeOut" },
            { false, FT_FLOAT, "FresnelCoefficient" },
            { false, FT_FLOAT, "GlowRed" },
            { false, FT_FLOAT, "GlowGreen" },
            { false, FT_FLOAT, "GlowBlue" },
            { false, FT_FLOAT, "GlowAlpha" },
            { false, FT_FLOAT, "GlowMultiplier" },
            { false, FT_FLOAT, "InitialDelay" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "CurveID" },
            { true, FT_INT, "Priority" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EdgeGlowEffectMeta::Instance(), HOTFIX_SEL_EDGE_GLOW_EFFECT);
        return &loadInfo;
    }
};

struct EmotesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_LONG, "RaceMask" },
            { false, FT_STRING, "EmoteSlashCommand" },
            { true, FT_INT, "EmoteFlags" },
            { true, FT_INT, "SpellVisualKitID" },
            { false, FT_SHORT, "AnimID" },
            { false, FT_BYTE, "EmoteSpecProc" },
            { true, FT_INT, "ClassMask" },
            { true, FT_INT, "EmoteSpecProcParam" },
            { true, FT_INT, "EventSoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EmotesMeta::Instance(), HOTFIX_SEL_EMOTES);
        return &loadInfo;
    }
};

struct EmotesTextLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "EmoteID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EmotesTextMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT);
        return &loadInfo;
    }
};

struct EmotesTextDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
            { false, FT_BYTE, "RelationshipFlags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EmotesTextDataMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT_DATA);
        return &loadInfo;
    }
};

struct EmotesTextSoundLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "SexID" },
            { false, FT_BYTE, "ClassID" },
            { true, FT_INT, "SoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EmotesTextSoundMeta::Instance(), HOTFIX_SEL_EMOTES_TEXT_SOUND);
        return &loadInfo;
    }
};

struct EnvironmentalDamageLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "VisualKitID" },
            { false, FT_BYTE, "EnumID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, EnvironmentalDamageMeta::Instance(), HOTFIX_SEL_ENVIRONMENTAL_DAMAGE);
        return &loadInfo;
    }
};

struct ExhaustionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "CombatLogText" },
            { false, FT_INT, "Xp" },
            { false, FT_FLOAT, "Factor" },
            { false, FT_FLOAT, "OutdoorHours" },
            { false, FT_FLOAT, "InnHours" },
            { false, FT_FLOAT, "Threshold" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ExhaustionMeta::Instance(), HOTFIX_SEL_EXHAUSTION);
        return &loadInfo;
    }
};

struct FactionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_LONG, "ReputationRaceMask1" },
            { true, FT_LONG, "ReputationRaceMask2" },
            { true, FT_LONG, "ReputationRaceMask3" },
            { true, FT_LONG, "ReputationRaceMask4" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "ReputationBase1" },
            { true, FT_INT, "ReputationBase2" },
            { true, FT_INT, "ReputationBase3" },
            { true, FT_INT, "ReputationBase4" },
            { false, FT_FLOAT, "ParentFactionMod1" },
            { false, FT_FLOAT, "ParentFactionMod2" },
            { false, FT_INT, "ReputationMax1" },
            { false, FT_INT, "ReputationMax2" },
            { false, FT_INT, "ReputationMax3" },
            { false, FT_INT, "ReputationMax4" },
            { true, FT_SHORT, "ReputationIndex" },
            { false, FT_SHORT, "ReputationClassMask1" },
            { false, FT_SHORT, "ReputationClassMask2" },
            { false, FT_SHORT, "ReputationClassMask3" },
            { false, FT_SHORT, "ReputationClassMask4" },
            { false, FT_SHORT, "ReputationFlags1" },
            { false, FT_SHORT, "ReputationFlags2" },
            { false, FT_SHORT, "ReputationFlags3" },
            { false, FT_SHORT, "ReputationFlags4" },
            { false, FT_SHORT, "ParentFactionID" },
            { false, FT_SHORT, "ParagonFactionID" },
            { false, FT_BYTE, "ParentFactionCap1" },
            { false, FT_BYTE, "ParentFactionCap2" },
            { false, FT_BYTE, "Expansion" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "FriendshipRepID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionMeta::Instance(), HOTFIX_SEL_FACTION);
        return &loadInfo;
    }
};

struct FactionGroupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "InternalName" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "MaskID" },
            { true, FT_INT, "HonorCurrencyTextureFileID" },
            { true, FT_INT, "ConquestCurrencyTextureFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionGroupMeta::Instance(), HOTFIX_SEL_FACTION_GROUP);
        return &loadInfo;
    }
};

struct FactionTemplateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Faction" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "Enemies1" },
            { false, FT_SHORT, "Enemies2" },
            { false, FT_SHORT, "Enemies3" },
            { false, FT_SHORT, "Enemies4" },
            { false, FT_SHORT, "Friend1" },
            { false, FT_SHORT, "Friend2" },
            { false, FT_SHORT, "Friend3" },
            { false, FT_SHORT, "Friend4" },
            { false, FT_BYTE, "FactionGroup" },
            { false, FT_BYTE, "FriendGroup" },
            { false, FT_BYTE, "EnemyGroup" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FactionTemplateMeta::Instance(), HOTFIX_SEL_FACTION_TEMPLATE);
        return &loadInfo;
    }
};

struct FootprintTexturesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "TextureBlendsetID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "FileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FootprintTexturesMeta::Instance(), HOTFIX_SEL_FOOTPRINT_TEXTURES);
        return &loadInfo;
    }
};

struct FootstepTerrainLookupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "CreatureFootstepID" },
            { false, FT_BYTE, "TerrainSoundID" },
            { true, FT_INT, "SoundID" },
            { true, FT_INT, "SoundIDSplash" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FootstepTerrainLookupMeta::Instance(), HOTFIX_SEL_FOOTSTEP_TERRAIN_LOOKUP);
        return &loadInfo;
    }
};

struct FriendshipRepReactionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Reaction" },
            { false, FT_SHORT, "ReactionThreshold" },
            { false, FT_BYTE, "FriendshipRepID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FriendshipRepReactionMeta::Instance(), HOTFIX_SEL_FRIENDSHIP_REP_REACTION);
        return &loadInfo;
    }
};

struct FriendshipReputationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Description" },
            { true, FT_INT, "TextureFileID" },
            { false, FT_SHORT, "FactionID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FriendshipReputationMeta::Instance(), HOTFIX_SEL_FRIENDSHIP_REPUTATION);
        return &loadInfo;
    }
};

struct FullScreenEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Saturation" },
            { false, FT_FLOAT, "GammaRed" },
            { false, FT_FLOAT, "GammaGreen" },
            { false, FT_FLOAT, "GammaBlue" },
            { false, FT_FLOAT, "MaskOffsetY" },
            { false, FT_FLOAT, "MaskSizeMultiplier" },
            { false, FT_FLOAT, "MaskPower" },
            { false, FT_FLOAT, "ColorMultiplyRed" },
            { false, FT_FLOAT, "ColorMultiplyGreen" },
            { false, FT_FLOAT, "ColorMultiplyBlue" },
            { false, FT_FLOAT, "ColorMultiplyOffsetY" },
            { false, FT_FLOAT, "ColorMultiplyMultiplier" },
            { false, FT_FLOAT, "ColorMultiplyPower" },
            { false, FT_FLOAT, "ColorAdditionRed" },
            { false, FT_FLOAT, "ColorAdditionGreen" },
            { false, FT_FLOAT, "ColorAdditionBlue" },
            { false, FT_FLOAT, "ColorAdditionOffsetY" },
            { false, FT_FLOAT, "ColorAdditionMultiplier" },
            { false, FT_FLOAT, "ColorAdditionPower" },
            { false, FT_FLOAT, "BlurIntensity" },
            { false, FT_FLOAT, "BlurOffsetY" },
            { false, FT_FLOAT, "BlurMultiplier" },
            { false, FT_FLOAT, "BlurPower" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "TextureBlendSetID" },
            { true, FT_INT, "EffectFadeInMs" },
            { true, FT_INT, "EffectFadeOutMs" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, FullScreenEffectMeta::Instance(), HOTFIX_SEL_FULL_SCREEN_EFFECT);
        return &loadInfo;
    }
};

struct GameobjectArtKitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "AttachModelFileID" },
            { true, FT_INT, "TextureVariationFileID1" },
            { true, FT_INT, "TextureVariationFileID2" },
            { true, FT_INT, "TextureVariationFileID3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectArtKitMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_ART_KIT);
        return &loadInfo;
    }
};

struct GameobjectDiffAnimMapLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "AttachmentDisplayID" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "Animation" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectDiffAnimMapMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DIFF_ANIM_MAP);
        return &loadInfo;
    }
};

struct GameobjectDisplayInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_FLOAT, "GeoBoxMinX" },
            { false, FT_FLOAT, "GeoBoxMinY" },
            { false, FT_FLOAT, "GeoBoxMinZ" },
            { false, FT_FLOAT, "GeoBoxMaxX" },
            { false, FT_FLOAT, "GeoBoxMaxY" },
            { false, FT_FLOAT, "GeoBoxMaxZ" },
            { false, FT_FLOAT, "OverrideLootEffectScale" },
            { false, FT_FLOAT, "OverrideNameScale" },
            { true, FT_SHORT, "ObjectEffectPackageID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectDisplayInfoMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO);
        return &loadInfo;
    }
};

struct GameobjectDisplayInfoXSoundKitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "EventIndex" },
            { true, FT_INT, "SoundKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectDisplayInfoXSoundKitMeta::Instance(), HOTFIX_SEL_GAMEOBJECT_DISPLAY_INFO_X_SOUND_KIT);
        return &loadInfo;
    }
};

struct GameobjectsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "PositionX" },
            { false, FT_FLOAT, "PositionY" },
            { false, FT_FLOAT, "PositionZ" },
            { false, FT_FLOAT, "RotationX" },
            { false, FT_FLOAT, "RotationY" },
            { false, FT_FLOAT, "RotationZ" },
            { false, FT_FLOAT, "RotationO" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_INT, "PropValue1" },
            { false, FT_INT, "PropValue2" },
            { false, FT_INT, "PropValue3" },
            { false, FT_INT, "PropValue4" },
            { false, FT_INT, "PropValue5" },
            { false, FT_INT, "PropValue6" },
            { false, FT_INT, "PropValue7" },
            { false, FT_INT, "PropValue8" },
            { false, FT_SHORT, "OwnerID" },
            { false, FT_SHORT, "DisplayID" },
            { false, FT_SHORT, "PhaseID" },
            { false, FT_SHORT, "PhaseGroupID" },
            { false, FT_BYTE, "PhaseUseFlags" },
            { false, FT_BYTE, "TypeID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameObjectsMeta::Instance(), HOTFIX_SEL_GAMEOBJECTS);
        return &loadInfo;
    }
};

struct GameTipsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
            { false, FT_SHORT, "MinLevel" },
            { false, FT_SHORT, "MaxLevel" },
            { false, FT_BYTE, "SortIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GameTipsMeta::Instance(), HOTFIX_SEL_GAME_TIPS);
        return &loadInfo;
    }
};

struct GarrAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "FactionChangeGarrAbilityID" },
            { false, FT_BYTE, "GarrAbilityCategoryID" },
            { false, FT_BYTE, "GarrFollowerTypeID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrAbilityMeta::Instance(), HOTFIX_SEL_GARR_ABILITY);
        return &loadInfo;
    }
};

struct GarrAbilityCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrAbilityCategoryMeta::Instance(), HOTFIX_SEL_GARR_ABILITY_CATEGORY);
        return &loadInfo;
    }
};

struct GarrAbilityEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "CombatWeightBase" },
            { false, FT_FLOAT, "CombatWeightMax" },
            { false, FT_FLOAT, "ActionValueFlat" },
            { true, FT_INT, "ActionRecordID" },
            { false, FT_SHORT, "GarrAbilityID" },
            { false, FT_BYTE, "AbilityAction" },
            { false, FT_BYTE, "AbilityTargetType" },
            { false, FT_BYTE, "GarrMechanicTypeID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "ActionRace" },
            { false, FT_BYTE, "ActionHours" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrAbilityEffectMeta::Instance(), HOTFIX_SEL_GARR_ABILITY_EFFECT);
        return &loadInfo;
    }
};

struct GarrBuildingLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "AllianceName" },
            { false, FT_STRING, "HordeName" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "Tooltip" },
            { true, FT_INT, "HordeGameObjectID" },
            { true, FT_INT, "AllianceGameObjectID" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_SHORT, "CurrencyTypeID" },
            { false, FT_SHORT, "HordeUiTextureKitID" },
            { false, FT_SHORT, "AllianceUiTextureKitID" },
            { false, FT_SHORT, "AllianceSceneScriptPackageID" },
            { false, FT_SHORT, "HordeSceneScriptPackageID" },
            { false, FT_SHORT, "GarrAbilityID" },
            { false, FT_SHORT, "BonusGarrAbilityID" },
            { true, FT_SHORT, "GoldCost" },
            { false, FT_BYTE, "GarrSiteID" },
            { false, FT_BYTE, "BuildingType" },
            { false, FT_BYTE, "UpgradeLevel" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "ShipmentCapacity" },
            { false, FT_BYTE, "GarrTypeID" },
            { true, FT_INT, "BuildSeconds" },
            { true, FT_INT, "CurrencyQty" },
            { true, FT_INT, "MaxAssignments" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingMeta::Instance(), HOTFIX_SEL_GARR_BUILDING);
        return &loadInfo;
    }
};

struct GarrBuildingDoodadSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "GarrBuildingID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "AllianceDoodadSet" },
            { false, FT_BYTE, "HordeDoodadSet" },
            { false, FT_BYTE, "SpecializationID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingDoodadSetMeta::Instance(), HOTFIX_SEL_GARR_BUILDING_DOODAD_SET);
        return &loadInfo;
    }
};

struct GarrBuildingPlotInstLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "MapOffsetX" },
            { false, FT_FLOAT, "MapOffsetY" },
            { false, FT_SHORT, "UiTextureAtlasMemberID" },
            { false, FT_SHORT, "GarrSiteLevelPlotInstID" },
            { false, FT_BYTE, "GarrBuildingID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrBuildingPlotInstMeta::Instance(), HOTFIX_SEL_GARR_BUILDING_PLOT_INST);
        return &loadInfo;
    }
};

struct GarrClassSpecLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "ClassSpec" },
            { false, FT_STRING, "ClassSpecMale" },
            { false, FT_STRING, "ClassSpecFemale" },
            { false, FT_SHORT, "UiTextureAtlasMemberID" },
            { false, FT_SHORT, "GarrFollItemSetID" },
            { false, FT_BYTE, "FollowerClassLimit" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrClassSpecMeta::Instance(), HOTFIX_SEL_GARR_CLASS_SPEC);
        return &loadInfo;
    }
};

struct GarrClassSpecPlayerCondLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_INT, "GarrClassSpecID" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "FlavorGarrStringID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrClassSpecPlayerCondMeta::Instance(), HOTFIX_SEL_GARR_CLASS_SPEC_PLAYER_COND);
        return &loadInfo;
    }
};

struct GarrEncounterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { true, FT_INT, "CreatureID" },
            { false, FT_FLOAT, "UiAnimScale" },
            { false, FT_FLOAT, "UiAnimHeight" },
            { true, FT_INT, "PortraitFileDataID" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "UiTextureKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrEncounterMeta::Instance(), HOTFIX_SEL_GARR_ENCOUNTER);
        return &loadInfo;
    }
};

struct GarrEncounterSetXEncounterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "xEncounter" },
            { false, FT_INT, "Encounter" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrEncounterSetXEncounterMeta::Instance(), HOTFIX_SEL_GARR_ENCOUNTER_SET_X_ENCOUNTER);
        return &loadInfo;
    }
};

struct GarrEncounterXMechanicLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "GarrMechanicID" },
            { false, FT_BYTE, "GarrMechanicSetID" },
            { false, FT_SHORT, "GarrEncounterID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrEncounterXMechanicMeta::Instance(), HOTFIX_SEL_GARR_ENCOUNTER_X_MECHANIC);
        return &loadInfo;
    }
};

struct GarrFollItemSetMemberLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "MinItemLevel" },
            { false, FT_BYTE, "ItemSlot" },
            { false, FT_SHORT, "GarrFollItemSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollItemSetMemberMeta::Instance(), HOTFIX_SEL_GARR_FOLL_ITEM_SET_MEMBER);
        return &loadInfo;
    }
};

struct GarrFollowerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "HordeSourceText" },
            { false, FT_STRING, "AllianceSourceText" },
            { false, FT_STRING, "TitleName" },
            { true, FT_INT, "HordeCreatureID" },
            { true, FT_INT, "AllianceCreatureID" },
            { true, FT_INT, "HordeIconFileDataID" },
            { true, FT_INT, "AllianceIconFileDataID" },
            { true, FT_INT, "HordeSlottingBroadcastTextID" },
            { true, FT_INT, "AllySlottingBroadcastTextID" },
            { false, FT_SHORT, "HordeGarrFollItemSetID" },
            { false, FT_SHORT, "AllianceGarrFollItemSetID" },
            { false, FT_SHORT, "ItemLevelWeapon" },
            { false, FT_SHORT, "ItemLevelArmor" },
            { false, FT_SHORT, "HordeUITextureKitID" },
            { false, FT_SHORT, "AllianceUITextureKitID" },
            { false, FT_BYTE, "GarrFollowerTypeID" },
            { false, FT_BYTE, "HordeGarrFollRaceID" },
            { false, FT_BYTE, "AllianceGarrFollRaceID" },
            { false, FT_BYTE, "Quality" },
            { false, FT_BYTE, "HordeGarrClassSpecID" },
            { false, FT_BYTE, "AllianceGarrClassSpecID" },
            { false, FT_BYTE, "FollowerLevel" },
            { false, FT_BYTE, "Gender" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "HordeSourceTypeEnum" },
            { false, FT_BYTE, "AllianceSourceTypeEnum" },
            { false, FT_BYTE, "GarrTypeID" },
            { false, FT_BYTE, "Vitality" },
            { false, FT_BYTE, "ChrClassID" },
            { false, FT_BYTE, "HordeFlavorGarrStringID" },
            { false, FT_BYTE, "AllianceFlavorGarrStringID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER);
        return &loadInfo;
    }
};

struct GarrFollowerLevelXPLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "XpToNextLevel" },
            { false, FT_SHORT, "ShipmentXP" },
            { false, FT_BYTE, "FollowerLevel" },
            { false, FT_BYTE, "GarrFollowerTypeID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerLevelXPMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_LEVEL_X_P);
        return &loadInfo;
    }
};

struct GarrFollowerQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "XpToNextQuality" },
            { false, FT_SHORT, "ShipmentXP" },
            { false, FT_BYTE, "Quality" },
            { false, FT_BYTE, "AbilityCount" },
            { false, FT_BYTE, "TraitCount" },
            { false, FT_BYTE, "GarrFollowerTypeID" },
            { true, FT_INT, "ClassSpecID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerQualityMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_QUALITY);
        return &loadInfo;
    }
};

struct GarrFollowerSetXFollowerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "GarrFollowerID" },
            { false, FT_INT, "GarrFollowerSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerSetXFollowerMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_SET_X_FOLLOWER);
        return &loadInfo;
    }
};

struct GarrFollowerTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MaxItemLevel" },
            { false, FT_BYTE, "MaxFollowers" },
            { false, FT_BYTE, "MaxFollowerBuildingType" },
            { false, FT_BYTE, "GarrTypeID" },
            { false, FT_BYTE, "LevelRangeBias" },
            { false, FT_BYTE, "ItemLevelRangeBias" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerTypeMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_TYPE);
        return &loadInfo;
    }
};

struct GarrFollowerUICreatureLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CreatureID" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_BYTE, "FactionIndex" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerUICreatureMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_U_I_CREATURE);
        return &loadInfo;
    }
};

struct GarrFollowerXAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "GarrAbilityID" },
            { false, FT_BYTE, "FactionIndex" },
            { false, FT_SHORT, "GarrFollowerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollowerXAbilityMeta::Instance(), HOTFIX_SEL_GARR_FOLLOWER_X_ABILITY);
        return &loadInfo;
    }
};

struct GarrFollSupportSpellLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "AllianceSpellID" },
            { true, FT_INT, "HordeSpellID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_INT, "GarrFollowerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrFollSupportSpellMeta::Instance(), HOTFIX_SEL_GARR_FOLL_SUPPORT_SPELL);
        return &loadInfo;
    }
};

struct GarrItemLevelUpgradeDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Operation" },
            { true, FT_INT, "MinItemLevel" },
            { true, FT_INT, "MaxItemLevel" },
            { true, FT_INT, "FollowerTypeID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrItemLevelUpgradeDataMeta::Instance(), HOTFIX_SEL_GARR_ITEM_LEVEL_UPGRADE_DATA);
        return &loadInfo;
    }
};

struct GarrMechanicLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Factor" },
            { false, FT_BYTE, "GarrMechanicTypeID" },
            { true, FT_INT, "GarrAbilityID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMechanicMeta::Instance(), HOTFIX_SEL_GARR_MECHANIC);
        return &loadInfo;
    }
};

struct GarrMechanicSetXMechanicLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_BYTE, "GarrMechanicID" },
            { true, FT_INT, "ID" },
            { false, FT_INT, "GarrMechanicSetId" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMechanicSetXMechanicMeta::Instance(), HOTFIX_SEL_GARR_MECHANIC_SET_X_MECHANIC);
        return &loadInfo;
    }
};

struct GarrMechanicTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_BYTE, "Category" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMechanicTypeMeta::Instance(), HOTFIX_SEL_GARR_MECHANIC_TYPE);
        return &loadInfo;
    }
};

struct GarrMissionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "Location" },
            { true, FT_INT, "MissionDuration" },
            { true, FT_INT, "OfferDuration" },
            { false, FT_FLOAT, "MapPos_1" },
            { false, FT_FLOAT, "MapPos_2" },
            { false, FT_FLOAT, "WorldPos1" },
            { false, FT_FLOAT, "WorldPos2" },
            { false, FT_SHORT, "TargetItemLevel" },
            { false, FT_SHORT, "UiTextureKitID" },
            { false, FT_SHORT, "MissionCostCurrencyTypesID" },
            { false, FT_BYTE, "TargetLevel" },
            { false, FT_BYTE, "EnvGarrMechanicTypeID" },
            { false, FT_BYTE, "MaxFollowers" },
            { false, FT_BYTE, "OfferedGarrMissionTextureID" },
            { false, FT_BYTE, "GarrMissionTypeID" },
            { false, FT_BYTE, "GarrFollowerTypeID" },
            { false, FT_BYTE, "BaseCompletionChance" },
            { false, FT_BYTE, "FollowerDeathChance" },
            { false, FT_BYTE, "GarrTypeID" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "TravelDuration" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "MissionCost" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "BaseFollowerXP" },
            { true, FT_INT, "AreaID" },
            { true, FT_INT, "OvermaxRewardPackID" },
            { true, FT_INT, "EnvGarrMechanicID" },
            { true, FT_INT, "RelationshipData" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMissionMeta::Instance(), HOTFIX_SEL_GARR_MISSION);
        return &loadInfo;
    }
};

struct GarrMissionTextureLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_SHORT, "UiTextureKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMissionTextureMeta::Instance(), HOTFIX_SEL_GARR_MISSION_TEXTURE);
        return &loadInfo;
    }
};

struct GarrMissionTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "UiTextureAtlasMemberID" },
            { false, FT_SHORT, "UiTextureKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMissionTypeMeta::Instance(), HOTFIX_SEL_GARR_MISSION_TYPE);
        return &loadInfo;
    }
};

struct GarrMissionXEncounterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_INT, "ID" },
            { false, FT_INT, "GarrMissionID" },
            { true, FT_INT, "GarrEncounterID" },
            { true, FT_INT, "GarrEncounterSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMissionXEncounterMeta::Instance(), HOTFIX_SEL_GARR_MISSION_X_ENCOUNTER);
        return &loadInfo;
    }
};

struct GarrMissionXFollowerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "GarrFollowerID" },
            { true, FT_INT, "GarrFollowerSetID" },
            { false, FT_INT, "GarrMissionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMissionXFollowerMeta::Instance(), HOTFIX_SEL_GARR_MISSION_X_FOLLOWER);
        return &loadInfo;
    }
};

struct GarrMssnBonusAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Radius" },
            { true, FT_INT, "DurationSecs" },
            { false, FT_SHORT, "GarrAbilityID" },
            { false, FT_BYTE, "GarrFollowerTypeID" },
            { false, FT_BYTE, "GarrMissionTextureID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrMssnBonusAbilityMeta::Instance(), HOTFIX_SEL_GARR_MSSN_BONUS_ABILITY);
        return &loadInfo;
    }
};

struct GarrPlotLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "AllianceConstructObjID" },
            { true, FT_INT, "HordeConstructObjID" },
            { false, FT_BYTE, "UiCategoryID" },
            { false, FT_BYTE, "PlotType" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "UpgradeRequirement1" },
            { true, FT_INT, "UpgradeRequirement2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrPlotMeta::Instance(), HOTFIX_SEL_GARR_PLOT);
        return &loadInfo;
    }
};

struct GarrPlotBuildingLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "GarrPlotID" },
            { false, FT_BYTE, "GarrBuildingID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrPlotBuildingMeta::Instance(), HOTFIX_SEL_GARR_PLOT_BUILDING);
        return &loadInfo;
    }
};

struct GarrPlotInstanceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "GarrPlotID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrPlotInstanceMeta::Instance(), HOTFIX_SEL_GARR_PLOT_INSTANCE);
        return &loadInfo;
    }
};

struct GarrPlotUICategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "CategoryName" },
            { false, FT_BYTE, "PlotType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrPlotUICategoryMeta::Instance(), HOTFIX_SEL_GARR_PLOT_U_I_CATEGORY);
        return &loadInfo;
    }
};

struct GarrSiteLevelLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "TownHallUiPos1" },
            { false, FT_FLOAT, "TownHallUiPos2" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "UiTextureKitID" },
            { false, FT_SHORT, "UpgradeMovieID" },
            { false, FT_SHORT, "UpgradeCost" },
            { false, FT_SHORT, "UpgradeGoldCost" },
            { false, FT_BYTE, "GarrLevel" },
            { false, FT_BYTE, "GarrSiteID" },
            { false, FT_BYTE, "MaxBuildingLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrSiteLevelMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL);
        return &loadInfo;
    }
};

struct GarrSiteLevelPlotInstLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "UiMarkerPos1" },
            { false, FT_FLOAT, "UiMarkerPos2" },
            { false, FT_SHORT, "GarrSiteLevelID" },
            { false, FT_BYTE, "GarrPlotInstanceID" },
            { false, FT_BYTE, "UiMarkerSize" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrSiteLevelPlotInstMeta::Instance(), HOTFIX_SEL_GARR_SITE_LEVEL_PLOT_INST);
        return &loadInfo;
    }
};

struct GarrSpecializationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Tooltip" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_FLOAT, "Param1" },
            { false, FT_FLOAT, "Param2" },
            { false, FT_BYTE, "BuildingType" },
            { false, FT_BYTE, "SpecType" },
            { false, FT_BYTE, "RequiredUpgradeLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrSpecializationMeta::Instance(), HOTFIX_SEL_GARR_SPECIALIZATION);
        return &loadInfo;
    }
};

struct GarrStringLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrStringMeta::Instance(), HOTFIX_SEL_GARR_STRING);
        return &loadInfo;
    }
};

struct GarrTalentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "IconFileDataID" },
            { true, FT_INT, "ResearchDurationSecs" },
            { false, FT_BYTE, "Tier" },
            { false, FT_BYTE, "UiOrder" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "GarrTalentTreeID" },
            { true, FT_INT, "GarrAbilityID" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "ResearchCost" },
            { true, FT_INT, "ResearchCostCurrencyTypesID" },
            { true, FT_INT, "ResearchGoldCost" },
            { true, FT_INT, "PerkSpellID" },
            { true, FT_INT, "PerkPlayerConditionID" },
            { true, FT_INT, "RespecCost" },
            { true, FT_INT, "RespecCostCurrencyTypesID" },
            { true, FT_INT, "RespecDurationSecs" },
            { true, FT_INT, "RespecGoldCost" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrTalentMeta::Instance(), HOTFIX_SEL_GARR_TALENT);
        return &loadInfo;
    }
};

struct GarrTalentTreeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "UiTextureKitID" },
            { false, FT_BYTE, "MaxTiers" },
            { false, FT_BYTE, "UiOrder" },
            { true, FT_INT, "ClassID" },
            { true, FT_INT, "GarrTypeID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrTalentTreeMeta::Instance(), HOTFIX_SEL_GARR_TALENT_TREE);
        return &loadInfo;
    }
};

struct GarrTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "PrimaryCurrencyTypeID" },
            { true, FT_INT, "SecondaryCurrencyTypeID" },
            { true, FT_INT, "ExpansionID" },
            { true, FT_INT, "MapIDs1" },
            { true, FT_INT, "MapIDs2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrTypeMeta::Instance(), HOTFIX_SEL_GARR_TYPE);
        return &loadInfo;
    }
};

struct GarrUiAnimClassInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ImpactDelaySecs" },
            { false, FT_BYTE, "GarrClassSpecID" },
            { false, FT_BYTE, "MovementType" },
            { true, FT_INT, "CastKit" },
            { true, FT_INT, "ImpactKit" },
            { true, FT_INT, "TargetImpactKit" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrUiAnimClassInfoMeta::Instance(), HOTFIX_SEL_GARR_UI_ANIM_CLASS_INFO);
        return &loadInfo;
    }
};

struct GarrUiAnimRaceInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "MaleScale" },
            { false, FT_FLOAT, "MaleHeight" },
            { false, FT_FLOAT, "MaleSingleModelScale" },
            { false, FT_FLOAT, "MaleSingleModelHeight" },
            { false, FT_FLOAT, "MaleFollowerPageScale" },
            { false, FT_FLOAT, "MaleFollowerPageHeight" },
            { false, FT_FLOAT, "FemaleScale" },
            { false, FT_FLOAT, "FemaleHeight" },
            { false, FT_FLOAT, "FemaleSingleModelScale" },
            { false, FT_FLOAT, "FemaleSingleModelHeight" },
            { false, FT_FLOAT, "FemaleFollowerPageScale" },
            { false, FT_FLOAT, "FemaleFollowerPageHeight" },
            { false, FT_BYTE, "GarrFollRaceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GarrUiAnimRaceInfoMeta::Instance(), HOTFIX_SEL_GARR_UI_ANIM_RACE_INFO);
        return &loadInfo;
    }
};

struct GemPropertiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Type" },
            { false, FT_SHORT, "EnchantID" },
            { false, FT_SHORT, "MinItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GemPropertiesMeta::Instance(), HOTFIX_SEL_GEM_PROPERTIES);
        return &loadInfo;
    }
};

struct GlobalStringsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "BaseTag" },
            { false, FT_STRING, "TagText" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GlobalStringsMeta::Instance(), HOTFIX_SEL_GLOBAL_STRINGS);
        return &loadInfo;
    }
};

struct GlyphBindableSpellLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "SpellID" },
            { false, FT_SHORT, "GlyphPropertiesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GlyphBindableSpellMeta::Instance(), HOTFIX_SEL_GLYPH_BINDABLE_SPELL);
        return &loadInfo;
    }
};

struct GlyphExclusiveCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GlyphExclusiveCategoryMeta::Instance(), HOTFIX_SEL_GLYPH_EXCLUSIVE_CATEGORY);
        return &loadInfo;
    }
};

struct GlyphPropertiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "SpellIconID" },
            { false, FT_BYTE, "GlyphType" },
            { false, FT_BYTE, "GlyphExclusiveCategoryID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GlyphPropertiesMeta::Instance(), HOTFIX_SEL_GLYPH_PROPERTIES);
        return &loadInfo;
    }
};

struct GlyphRequiredSpecLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ChrSpecializationID" },
            { false, FT_SHORT, "GlyphPropertiesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GlyphRequiredSpecMeta::Instance(), HOTFIX_SEL_GLYPH_REQUIRED_SPEC);
        return &loadInfo;
    }
};

struct GMSurveyAnswersLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Answer" },
            { false, FT_BYTE, "SortIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GMSurveyAnswersMeta::Instance(), HOTFIX_SEL_G_M_SURVEY_ANSWERS);
        return &loadInfo;
    }
};

struct GMSurveyCurrentSurveyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "GmsurveyID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GMSurveyCurrentSurveyMeta::Instance(), HOTFIX_SEL_G_M_SURVEY_CURRENT_SURVEY);
        return &loadInfo;
    }
};

struct GMSurveyQuestionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Question" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GMSurveyQuestionsMeta::Instance(), HOTFIX_SEL_G_M_SURVEY_QUESTIONS);
        return &loadInfo;
    }
};

struct GMSurveySurveysLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Q1" },
            { false, FT_BYTE, "Q2" },
            { false, FT_BYTE, "Q3" },
            { false, FT_BYTE, "Q4" },
            { false, FT_BYTE, "Q5" },
            { false, FT_BYTE, "Q6" },
            { false, FT_BYTE, "Q7" },
            { false, FT_BYTE, "Q8" },
            { false, FT_BYTE, "Q9" },
            { false, FT_BYTE, "Q10" },
            { false, FT_BYTE, "Q11" },
            { false, FT_BYTE, "Q12" },
            { false, FT_BYTE, "Q13" },
            { false, FT_BYTE, "Q14" },
            { false, FT_BYTE, "Q15" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GMSurveySurveysMeta::Instance(), HOTFIX_SEL_G_M_SURVEY_SURVEYS);
        return &loadInfo;
    }
};

struct GroundEffectDoodadLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Animscale" },
            { false, FT_FLOAT, "PushScale" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ModelFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GroundEffectDoodadMeta::Instance(), HOTFIX_SEL_GROUND_EFFECT_DOODAD);
        return &loadInfo;
    }
};

struct GroundEffectTextureLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "DoodadID1" },
            { false, FT_SHORT, "DoodadID2" },
            { false, FT_SHORT, "DoodadID3" },
            { false, FT_SHORT, "DoodadID4" },
            { false, FT_BYTE, "DoodadWeight1" },
            { false, FT_BYTE, "DoodadWeight2" },
            { false, FT_BYTE, "DoodadWeight3" },
            { false, FT_BYTE, "DoodadWeight4" },
            { false, FT_BYTE, "Sound" },
            { true, FT_INT, "Density" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GroundEffectTextureMeta::Instance(), HOTFIX_SEL_GROUND_EFFECT_TEXTURE);
        return &loadInfo;
    }
};

struct GroupFinderActivityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "FullName" },
            { false, FT_STRING, "ShortName" },
            { false, FT_SHORT, "MinGearLevelSuggestion" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_BYTE, "GroupFinderCategoryID" },
            { false, FT_BYTE, "GroupFinderActivityGrpID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "MaxLevelSuggestion" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "DisplayType" },
            { false, FT_BYTE, "MaxPlayers" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GroupFinderActivityMeta::Instance(), HOTFIX_SEL_GROUP_FINDER_ACTIVITY);
        return &loadInfo;
    }
};

struct GroupFinderActivityGrpLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GroupFinderActivityGrpMeta::Instance(), HOTFIX_SEL_GROUP_FINDER_ACTIVITY_GRP);
        return &loadInfo;
    }
};

struct GroupFinderCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GroupFinderCategoryMeta::Instance(), HOTFIX_SEL_GROUP_FINDER_CATEGORY);
        return &loadInfo;
    }
};

struct GuildColorBackgroundLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Red" },
            { false, FT_BYTE, "Green" },
            { false, FT_BYTE, "Blue" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorBackgroundMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BACKGROUND);
        return &loadInfo;
    }
};

struct GuildColorBorderLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Red" },
            { false, FT_BYTE, "Green" },
            { false, FT_BYTE, "Blue" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorBorderMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_BORDER);
        return &loadInfo;
    }
};

struct GuildColorEmblemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Red" },
            { false, FT_BYTE, "Green" },
            { false, FT_BYTE, "Blue" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildColorEmblemMeta::Instance(), HOTFIX_SEL_GUILD_COLOR_EMBLEM);
        return &loadInfo;
    }
};

struct GuildPerkSpellsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, GuildPerkSpellsMeta::Instance(), HOTFIX_SEL_GUILD_PERK_SPELLS);
        return &loadInfo;
    }
};

struct HeirloomLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "SourceText" },
            { true, FT_INT, "ItemID" },
            { true, FT_INT, "LegacyItemID" },
            { true, FT_INT, "LegacyUpgradedItemID" },
            { true, FT_INT, "StaticUpgradedItemID" },
            { true, FT_INT, "UpgradeItemID1" },
            { true, FT_INT, "UpgradeItemID2" },
            { true, FT_INT, "UpgradeItemID3" },
            { false, FT_SHORT, "UpgradeItemBonusListID1" },
            { false, FT_SHORT, "UpgradeItemBonusListID2" },
            { false, FT_SHORT, "UpgradeItemBonusListID3" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "SourceTypeEnum" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HeirloomMeta::Instance(), HOTFIX_SEL_HEIRLOOM);
        return &loadInfo;
    }
};

struct HelmetAnimScalingLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Amount" },
            { true, FT_INT, "RaceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HelmetAnimScalingMeta::Instance(), HOTFIX_SEL_HELMET_ANIM_SCALING);
        return &loadInfo;
    }
};

struct HelmetGeosetVisDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "HideGeoset1" },
            { false, FT_INT, "HideGeoset2" },
            { false, FT_INT, "HideGeoset3" },
            { false, FT_INT, "HideGeoset4" },
            { false, FT_INT, "HideGeoset5" },
            { false, FT_INT, "HideGeoset6" },
            { false, FT_INT, "HideGeoset7" },
            { false, FT_INT, "HideGeoset8" },
            { false, FT_INT, "HideGeoset9" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HelmetGeosetVisDataMeta::Instance(), HOTFIX_SEL_HELMET_GEOSET_VIS_DATA);
        return &loadInfo;
    }
};

struct HighlightColorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "StartColor" },
            { false, FT_INT, "MidColor" },
            { false, FT_INT, "EndColor" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HighlightColorMeta::Instance(), HOTFIX_SEL_HIGHLIGHT_COLOR);
        return &loadInfo;
    }
};

struct HolidayDescriptionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HolidayDescriptionsMeta::Instance(), HOTFIX_SEL_HOLIDAY_DESCRIPTIONS);
        return &loadInfo;
    }
};

struct HolidayNamesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HolidayNamesMeta::Instance(), HOTFIX_SEL_HOLIDAY_NAMES);
        return &loadInfo;
    }
};

struct HolidaysLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Date1" },
            { true, FT_INT, "Date2" },
            { true, FT_INT, "Date3" },
            { true, FT_INT, "Date4" },
            { true, FT_INT, "Date5" },
            { true, FT_INT, "Date6" },
            { true, FT_INT, "Date7" },
            { true, FT_INT, "Date8" },
            { true, FT_INT, "Date9" },
            { true, FT_INT, "Date10" },
            { true, FT_INT, "Date11" },
            { true, FT_INT, "Date12" },
            { true, FT_INT, "Date13" },
            { true, FT_INT, "Date14" },
            { true, FT_INT, "Date15" },
            { true, FT_INT, "Date16" },
            { false, FT_SHORT, "Duration1" },
            { false, FT_SHORT, "Duration2" },
            { false, FT_SHORT, "Duration3" },
            { false, FT_SHORT, "Duration4" },
            { false, FT_SHORT, "Duration5" },
            { false, FT_SHORT, "Duration6" },
            { false, FT_SHORT, "Duration7" },
            { false, FT_SHORT, "Duration8" },
            { false, FT_SHORT, "Duration9" },
            { false, FT_SHORT, "Duration10" },
            { false, FT_SHORT, "Region" },
            { false, FT_BYTE, "Looping" },
            { false, FT_BYTE, "CalendarFlags1" },
            { false, FT_BYTE, "CalendarFlags2" },
            { false, FT_BYTE, "CalendarFlags3" },
            { false, FT_BYTE, "CalendarFlags4" },
            { false, FT_BYTE, "CalendarFlags5" },
            { false, FT_BYTE, "CalendarFlags6" },
            { false, FT_BYTE, "CalendarFlags7" },
            { false, FT_BYTE, "CalendarFlags8" },
            { false, FT_BYTE, "CalendarFlags9" },
            { false, FT_BYTE, "CalendarFlags10" },
            { false, FT_BYTE, "Priority" },
            { true, FT_BYTE, "CalendarFilterType" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "HolidayNameID" },
            { true, FT_INT, "HolidayDescriptionID" },
            { true, FT_INT, "TextureFileDataID1" },
            { true, FT_INT, "TextureFileDataID2" },
            { true, FT_INT, "TextureFileDataID3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HolidaysMeta::Instance(), HOTFIX_SEL_HOLIDAYS);
        return &loadInfo;
    }
};

struct HotfixLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Tablename" },
            { true, FT_INT, "ObjectID" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, HotfixMeta::Instance(), HOTFIX_SEL_HOTFIX);
        return &loadInfo;
    }
};

struct ImportPriceArmorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ClothModifier" },
            { false, FT_FLOAT, "LeatherModifier" },
            { false, FT_FLOAT, "ChainModifier" },
            { false, FT_FLOAT, "PlateModifier" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ImportPriceArmorMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_ARMOR);
        return &loadInfo;
    }
};

struct ImportPriceQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Data" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ImportPriceQualityMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_QUALITY);
        return &loadInfo;
    }
};

struct ImportPriceShieldLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Data" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ImportPriceShieldMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_SHIELD);
        return &loadInfo;
    }
};

struct ImportPriceWeaponLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Data" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ImportPriceWeaponMeta::Instance(), HOTFIX_SEL_IMPORT_PRICE_WEAPON);
        return &loadInfo;
    }
};

struct InvasionClientDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "IconLocation1" },
            { false, FT_FLOAT, "IconLocation2" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "WorldStateID" },
            { true, FT_INT, "UiTextureAtlasMemberID" },
            { true, FT_INT, "ScenarioID" },
            { true, FT_INT, "WorldQuestID" },
            { true, FT_INT, "WorldStateValue" },
            { true, FT_INT, "InvasionEnabledWorldStateID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, InvasionClientDataMeta::Instance(), HOTFIX_SEL_INVASION_CLIENT_DATA);
        return &loadInfo;
    }
};

struct ItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "SubclassID" },
            { true, FT_BYTE, "SoundOverrideSubclass" },
            { true, FT_BYTE, "Material" },
            { false, FT_BYTE, "InventoryType" },
            { false, FT_BYTE, "SheatheType" },
            { false, FT_BYTE, "ItemGroupSoundsID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemMeta::Instance(), HOTFIX_SEL_ITEM);
        return &loadInfo;
    }
};

struct ItemAppearanceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemDisplayInfoID" },
            { true, FT_INT, "DefaultIconFileDataID" },
            { true, FT_INT, "UiOrder" },
            { false, FT_BYTE, "DisplayType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_APPEARANCE);
        return &loadInfo;
    }
};

struct ItemAppearanceXUiCameraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ItemAppearanceID" },
            { false, FT_SHORT, "UiCameraID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemAppearanceXUiCameraMeta::Instance(), HOTFIX_SEL_ITEM_APPEARANCE_X_UI_CAMERA);
        return &loadInfo;
    }
};

struct ItemArmorQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Qualitymod1" },
            { false, FT_FLOAT, "Qualitymod2" },
            { false, FT_FLOAT, "Qualitymod3" },
            { false, FT_FLOAT, "Qualitymod4" },
            { false, FT_FLOAT, "Qualitymod5" },
            { false, FT_FLOAT, "Qualitymod6" },
            { false, FT_FLOAT, "Qualitymod7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorQualityMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_QUALITY);
        return &loadInfo;
    }
};

struct ItemArmorShieldLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Quality1" },
            { false, FT_FLOAT, "Quality2" },
            { false, FT_FLOAT, "Quality3" },
            { false, FT_FLOAT, "Quality4" },
            { false, FT_FLOAT, "Quality5" },
            { false, FT_FLOAT, "Quality6" },
            { false, FT_FLOAT, "Quality7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorShieldMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_SHIELD);
        return &loadInfo;
    }
};

struct ItemArmorTotalLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Cloth" },
            { false, FT_FLOAT, "Leather" },
            { false, FT_FLOAT, "Mail" },
            { false, FT_FLOAT, "Plate" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemArmorTotalMeta::Instance(), HOTFIX_SEL_ITEM_ARMOR_TOTAL);
        return &loadInfo;
    }
};

struct ItemBagFamilyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemBagFamilyMeta::Instance(), HOTFIX_SEL_ITEM_BAG_FAMILY);
        return &loadInfo;
    }
};

struct ItemBonusLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Value1" },
            { true, FT_INT, "Value2" },
            { true, FT_INT, "Value3" },
            { false, FT_SHORT, "ParentItemBonusListID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemBonusMeta::Instance(), HOTFIX_SEL_ITEM_BONUS);
        return &loadInfo;
    }
};

struct ItemBonusListLevelDeltaLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_SHORT, "ItemLevelDelta" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemBonusListLevelDeltaMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_LIST_LEVEL_DELTA);
        return &loadInfo;
    }
};

struct ItemBonusTreeNodeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ChildItemBonusTreeID" },
            { false, FT_SHORT, "ChildItemBonusListID" },
            { false, FT_SHORT, "ChildItemLevelSelectorID" },
            { false, FT_BYTE, "ItemContext" },
            { false, FT_SHORT, "BonusTreeID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemBonusTreeNodeMeta::Instance(), HOTFIX_SEL_ITEM_BONUS_TREE_NODE);
        return &loadInfo;
    }
};

struct ItemChildEquipmentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ChildItemID" },
            { true, FT_BYTE, "ChildItemEquipSlot" },
            { false, FT_INT, "ItemID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemChildEquipmentMeta::Instance(), HOTFIX_SEL_ITEM_CHILD_EQUIPMENT);
        return &loadInfo;
    }
};

struct ItemClassLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "ClassName" },
            { false, FT_FLOAT, "PriceModifier" },
            { false, FT_BYTE, "OldEnumValue" },
            { false, FT_BYTE, "Class" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemClassMeta::Instance(), HOTFIX_SEL_ITEM_CLASS);
        return &loadInfo;
    }
};

struct ItemCurrencyCostLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemCurrencyCostMeta::Instance(), HOTFIX_SEL_ITEM_CURRENCY_COST);
        return &loadInfo;
    }
};

struct ItemDamageAmmoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Quality1" },
            { false, FT_FLOAT, "Quality2" },
            { false, FT_FLOAT, "Quality3" },
            { false, FT_FLOAT, "Quality4" },
            { false, FT_FLOAT, "Quality5" },
            { false, FT_FLOAT, "Quality6" },
            { false, FT_FLOAT, "Quality7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageAmmoMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_AMMO);
        return &loadInfo;
    }
};

struct ItemDamageOneHandLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Quality1" },
            { false, FT_FLOAT, "Quality2" },
            { false, FT_FLOAT, "Quality3" },
            { false, FT_FLOAT, "Quality4" },
            { false, FT_FLOAT, "Quality5" },
            { false, FT_FLOAT, "Quality6" },
            { false, FT_FLOAT, "Quality7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageOneHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND);
        return &loadInfo;
    }
};

struct ItemDamageOneHandCasterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Quality1" },
            { false, FT_FLOAT, "Quality2" },
            { false, FT_FLOAT, "Quality3" },
            { false, FT_FLOAT, "Quality4" },
            { false, FT_FLOAT, "Quality5" },
            { false, FT_FLOAT, "Quality6" },
            { false, FT_FLOAT, "Quality7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageOneHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_ONE_HAND_CASTER);
        return &loadInfo;
    }
};

struct ItemDamageTwoHandLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Quality1" },
            { false, FT_FLOAT, "Quality2" },
            { false, FT_FLOAT, "Quality3" },
            { false, FT_FLOAT, "Quality4" },
            { false, FT_FLOAT, "Quality5" },
            { false, FT_FLOAT, "Quality6" },
            { false, FT_FLOAT, "Quality7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageTwoHandMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND);
        return &loadInfo;
    }
};

struct ItemDamageTwoHandCasterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Quality1" },
            { false, FT_FLOAT, "Quality2" },
            { false, FT_FLOAT, "Quality3" },
            { false, FT_FLOAT, "Quality4" },
            { false, FT_FLOAT, "Quality5" },
            { false, FT_FLOAT, "Quality6" },
            { false, FT_FLOAT, "Quality7" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDamageTwoHandCasterMeta::Instance(), HOTFIX_SEL_ITEM_DAMAGE_TWO_HAND_CASTER);
        return &loadInfo;
    }
};

struct ItemDisenchantLootLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MinLevel" },
            { false, FT_SHORT, "MaxLevel" },
            { false, FT_SHORT, "SkillRequired" },
            { true, FT_BYTE, "Subclass" },
            { false, FT_BYTE, "Quality" },
            { true, FT_BYTE, "ExpansionID" },
            { false, FT_BYTE, "ItemClass" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDisenchantLootMeta::Instance(), HOTFIX_SEL_ITEM_DISENCHANT_LOOT);
        return &loadInfo;
    }
};

struct ItemDisplayInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "ItemRangedDisplayInfoID" },
            { true, FT_INT, "ItemVisual" },
            { true, FT_INT, "ParticleColorID" },
            { true, FT_INT, "OverrideSwooshSoundKitID" },
            { true, FT_INT, "SheatheTransformMatrixID" },
            { true, FT_INT, "ModelType1" },
            { true, FT_INT, "StateSpellVisualKitID" },
            { true, FT_INT, "SheathedSpellVisualKitID" },
            { true, FT_INT, "UnsheathedSpellVisualKitID" },
            { true, FT_INT, "ModelResourcesID1" },
            { true, FT_INT, "ModelResourcesID2" },
            { true, FT_INT, "ModelMaterialResourcesID1" },
            { true, FT_INT, "ModelMaterialResourcesID2" },
            { true, FT_INT, "GeosetGroup1" },
            { true, FT_INT, "GeosetGroup2" },
            { true, FT_INT, "GeosetGroup3" },
            { true, FT_INT, "GeosetGroup4" },
            { true, FT_INT, "AttachmentGeosetGroup1" },
            { true, FT_INT, "AttachmentGeosetGroup2" },
            { true, FT_INT, "AttachmentGeosetGroup3" },
            { true, FT_INT, "AttachmentGeosetGroup4" },
            { true, FT_INT, "HelmetGeosetVis1" },
            { true, FT_INT, "HelmetGeosetVis2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDisplayInfoMeta::Instance(), HOTFIX_SEL_ITEM_DISPLAY_INFO);
        return &loadInfo;
    }
};

struct ItemDisplayInfoMaterialResLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "MaterialResourcesID" },
            { false, FT_BYTE, "ComponentSection" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDisplayInfoMaterialResMeta::Instance(), HOTFIX_SEL_ITEM_DISPLAY_INFO_MATERIAL_RES);
        return &loadInfo;
    }
};

struct ItemDisplayXUiCameraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemDisplayInfoID" },
            { false, FT_SHORT, "UiCameraID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemDisplayXUiCameraMeta::Instance(), HOTFIX_SEL_ITEM_DISPLAY_X_UI_CAMERA);
        return &loadInfo;
    }
};

struct ItemEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "CoolDownMSec" },
            { true, FT_INT, "CategoryCoolDownMSec" },
            { true, FT_SHORT, "Charges" },
            { false, FT_SHORT, "SpellCategoryID" },
            { false, FT_SHORT, "ChrSpecializationID" },
            { false, FT_BYTE, "LegacySlotIndex" },
            { false, FT_BYTE, "TriggerType" },
            { false, FT_INT, "ItemID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemEffectMeta::Instance(), HOTFIX_SEL_ITEM_EFFECT);
        return &loadInfo;
    }
};

struct ItemExtendedCostLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID1" },
            { true, FT_INT, "ItemID2" },
            { true, FT_INT, "ItemID3" },
            { true, FT_INT, "ItemID4" },
            { true, FT_INT, "ItemID5" },
            { true, FT_INT, "CurrencyCount1" },
            { true, FT_INT, "CurrencyCount2" },
            { true, FT_INT, "CurrencyCount3" },
            { true, FT_INT, "CurrencyCount4" },
            { true, FT_INT, "CurrencyCount5" },
            { false, FT_SHORT, "ItemCount1" },
            { false, FT_SHORT, "ItemCount2" },
            { false, FT_SHORT, "ItemCount3" },
            { false, FT_SHORT, "ItemCount4" },
            { false, FT_SHORT, "ItemCount5" },
            { false, FT_SHORT, "RequiredArenaRating" },
            { false, FT_SHORT, "CurrencyID1" },
            { false, FT_SHORT, "CurrencyID2" },
            { false, FT_SHORT, "CurrencyID3" },
            { false, FT_SHORT, "CurrencyID4" },
            { false, FT_SHORT, "CurrencyID5" },
            { false, FT_BYTE, "ArenaBracket" },
            { false, FT_BYTE, "MinFactionID" },
            { false, FT_BYTE, "MinReputation" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "RequiredAchievement" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemExtendedCostMeta::Instance(), HOTFIX_SEL_ITEM_EXTENDED_COST);
        return &loadInfo;
    }
};

struct ItemGroupSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Sound1" },
            { true, FT_INT, "Sound2" },
            { true, FT_INT, "Sound3" },
            { true, FT_INT, "Sound4" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemGroupSoundsMeta::Instance(), HOTFIX_SEL_ITEM_GROUP_SOUNDS);
        return &loadInfo;
    }
};

struct ItemLevelSelectorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MinItemLevel" },
            { false, FT_SHORT, "ItemLevelSelectorQualitySetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemLevelSelectorMeta::Instance(), HOTFIX_SEL_ITEM_LEVEL_SELECTOR);
        return &loadInfo;
    }
};

struct ItemLevelSelectorQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "QualityItemBonusListID" },
            { false, FT_BYTE, "Quality" },
            { false, FT_SHORT, "ItemLevelSelectorQualitySetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemLevelSelectorQualityMeta::Instance(), HOTFIX_SEL_ITEM_LEVEL_SELECTOR_QUALITY);
        return &loadInfo;
    }
};

struct ItemLevelSelectorQualitySetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "IlvlRare" },
            { false, FT_SHORT, "IlvlEpic" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemLevelSelectorQualitySetMeta::Instance(), HOTFIX_SEL_ITEM_LEVEL_SELECTOR_QUALITY_SET);
        return &loadInfo;
    }
};

struct ItemLimitCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Quantity" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemLimitCategoryMeta::Instance(), HOTFIX_SEL_ITEM_LIMIT_CATEGORY);
        return &loadInfo;
    }
};

struct ItemLimitCategoryConditionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_BYTE, "AddQuantity" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "ParentItemLimitCategoryID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemLimitCategoryConditionMeta::Instance(), HOTFIX_SEL_ITEM_LIMIT_CATEGORY_CONDITION);
        return &loadInfo;
    }
};

struct ItemModifiedAppearanceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ItemID" },
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "ItemAppearanceModifierID" },
            { false, FT_SHORT, "ItemAppearanceID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "TransmogSourceTypeEnum" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemModifiedAppearanceMeta::Instance(), HOTFIX_SEL_ITEM_MODIFIED_APPEARANCE);
        return &loadInfo;
    }
};

struct ItemModifiedAppearanceExtraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "IconFileDataID" },
            { true, FT_INT, "UnequippedIconFileDataID" },
            { false, FT_BYTE, "SheatheType" },
            { false, FT_BYTE, "DisplayWeaponSubclassID" },
            { false, FT_BYTE, "DisplayInventoryType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemModifiedAppearanceExtraMeta::Instance(), HOTFIX_SEL_ITEM_MODIFIED_APPEARANCE_EXTRA);
        return &loadInfo;
    }
};

struct ItemNameDescriptionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { false, FT_INT, "Color" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemNameDescriptionMeta::Instance(), HOTFIX_SEL_ITEM_NAME_DESCRIPTION);
        return &loadInfo;
    }
};

struct ItemPetFoodLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemPetFoodMeta::Instance(), HOTFIX_SEL_ITEM_PET_FOOD);
        return &loadInfo;
    }
};

struct ItemPriceBaseLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Armor" },
            { false, FT_FLOAT, "Weapon" },
            { false, FT_SHORT, "ItemLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemPriceBaseMeta::Instance(), HOTFIX_SEL_ITEM_PRICE_BASE);
        return &loadInfo;
    }
};

struct ItemRandomPropertiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "Enchantment1" },
            { false, FT_SHORT, "Enchantment2" },
            { false, FT_SHORT, "Enchantment3" },
            { false, FT_SHORT, "Enchantment4" },
            { false, FT_SHORT, "Enchantment5" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemRandomPropertiesMeta::Instance(), HOTFIX_SEL_ITEM_RANDOM_PROPERTIES);
        return &loadInfo;
    }
};

struct ItemRandomSuffixLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "Enchantment1" },
            { false, FT_SHORT, "Enchantment2" },
            { false, FT_SHORT, "Enchantment3" },
            { false, FT_SHORT, "Enchantment4" },
            { false, FT_SHORT, "Enchantment5" },
            { false, FT_SHORT, "AllocationPct1" },
            { false, FT_SHORT, "AllocationPct2" },
            { false, FT_SHORT, "AllocationPct3" },
            { false, FT_SHORT, "AllocationPct4" },
            { false, FT_SHORT, "AllocationPct5" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemRandomSuffixMeta::Instance(), HOTFIX_SEL_ITEM_RANDOM_SUFFIX);
        return &loadInfo;
    }
};

struct ItemRangedDisplayInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "MissileSpellVisualEffectNameID" },
            { true, FT_INT, "QuiverFileDataID" },
            { true, FT_INT, "CastSpellVisualID" },
            { true, FT_INT, "AutoAttackSpellVisualID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemRangedDisplayInfoMeta::Instance(), HOTFIX_SEL_ITEM_RANGED_DISPLAY_INFO);
        return &loadInfo;
    }
};

struct ItemSearchNameLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_LONG, "AllowableRace" },
            { false, FT_STRING, "Display" },
            { true, FT_INT, "ID" },
            { false, FT_INT, "Flags1" },
            { false, FT_INT, "Flags2" },
            { false, FT_INT, "Flags3" },
            { false, FT_SHORT, "ItemLevel" },
            { false, FT_BYTE, "OverallQualityID" },
            { false, FT_BYTE, "ExpansionID" },
            { false, FT_BYTE, "RequiredLevel" },
            { false, FT_SHORT, "MinFactionID" },
            { false, FT_BYTE, "MinReputation" },
            { true, FT_INT, "AllowableClass" },
            { false, FT_SHORT, "RequiredSkill" },
            { false, FT_SHORT, "RequiredSkillRank" },
            { true, FT_INT, "RequiredAbility" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSearchNameMeta::Instance(), HOTFIX_SEL_ITEM_SEARCH_NAME);
        return &loadInfo;
    }
};

struct ItemSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ItemID1" },
            { true, FT_INT, "ItemID2" },
            { true, FT_INT, "ItemID3" },
            { true, FT_INT, "ItemID4" },
            { true, FT_INT, "ItemID5" },
            { true, FT_INT, "ItemID6" },
            { true, FT_INT, "ItemID7" },
            { true, FT_INT, "ItemID8" },
            { true, FT_INT, "ItemID9" },
            { true, FT_INT, "ItemID10" },
            { true, FT_INT, "ItemID11" },
            { true, FT_INT, "ItemID12" },
            { true, FT_INT, "ItemID13" },
            { true, FT_INT, "ItemID14" },
            { true, FT_INT, "ItemID15" },
            { true, FT_INT, "ItemID16" },
            { true, FT_INT, "ItemID17" },
            { false, FT_SHORT, "RequiredSkillRank" },
            { true, FT_INT, "RequiredSkill" },
            { true, FT_INT, "SetFlags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSetMeta::Instance(), HOTFIX_SEL_ITEM_SET);
        return &loadInfo;
    }
};

struct ItemSetSpellLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "ChrSpecID" },
            { false, FT_BYTE, "Threshold" },
            { false, FT_SHORT, "ItemSetID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSetSpellMeta::Instance(), HOTFIX_SEL_ITEM_SET_SPELL);
        return &loadInfo;
    }
};

struct ItemSparseLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_LONG, "AllowableRace" },
            { false, FT_STRING, "Display" },
            { false, FT_STRING, "Display1" },
            { false, FT_STRING, "Display2" },
            { false, FT_STRING, "Display3" },
            { false, FT_STRING, "Description" },
            { false, FT_INT, "Flags1" },
            { false, FT_INT, "Flags2" },
            { false, FT_INT, "Flags3" },
            { false, FT_INT, "Flags4" },
            { false, FT_FLOAT, "PriceRandomValue" },
            { false, FT_FLOAT, "PriceVariance" },
            { true, FT_INT, "VendorStackCount" },
            { true, FT_INT, "BuyPrice" },
            { true, FT_INT, "SellPrice" },
            { true, FT_INT, "RequiredAbility" },
            { true, FT_INT, "MaxCount" },
            { true, FT_INT, "Stackable" },
            { true, FT_INT, "StatPercentEditor1" },
            { true, FT_INT, "StatPercentEditor2" },
            { true, FT_INT, "StatPercentEditor3" },
            { true, FT_INT, "StatPercentEditor4" },
            { true, FT_INT, "StatPercentEditor5" },
            { true, FT_INT, "StatPercentEditor6" },
            { true, FT_INT, "StatPercentEditor7" },
            { true, FT_INT, "StatPercentEditor8" },
            { true, FT_INT, "StatPercentEditor9" },
            { true, FT_INT, "StatPercentEditor10" },
            { false, FT_FLOAT, "StatPercentageOfSocket1" },
            { false, FT_FLOAT, "StatPercentageOfSocket2" },
            { false, FT_FLOAT, "StatPercentageOfSocket3" },
            { false, FT_FLOAT, "StatPercentageOfSocket4" },
            { false, FT_FLOAT, "StatPercentageOfSocket5" },
            { false, FT_FLOAT, "StatPercentageOfSocket6" },
            { false, FT_FLOAT, "StatPercentageOfSocket7" },
            { false, FT_FLOAT, "StatPercentageOfSocket8" },
            { false, FT_FLOAT, "StatPercentageOfSocket9" },
            { false, FT_FLOAT, "StatPercentageOfSocket10" },
            { false, FT_FLOAT, "ItemRange" },
            { true, FT_INT, "BagFamily" },
            { false, FT_FLOAT, "QualityModifier" },
            { true, FT_INT, "DurationInInventory" },
            { false, FT_FLOAT, "DmgVariance" },
            { false, FT_SHORT, "AllowableClass" },
            { false, FT_SHORT, "ItemLevel" },
            { false, FT_SHORT, "RequiredSkill" },
            { false, FT_SHORT, "RequiredSkillRank" },
            { false, FT_SHORT, "MinFactionID" },
            { true, FT_SHORT, "ItemStatValue1" },
            { true, FT_SHORT, "ItemStatValue2" },
            { true, FT_SHORT, "ItemStatValue3" },
            { true, FT_SHORT, "ItemStatValue4" },
            { true, FT_SHORT, "ItemStatValue5" },
            { true, FT_SHORT, "ItemStatValue6" },
            { true, FT_SHORT, "ItemStatValue7" },
            { true, FT_SHORT, "ItemStatValue8" },
            { true, FT_SHORT, "ItemStatValue9" },
            { true, FT_SHORT, "ItemStatValue10" },
            { false, FT_SHORT, "ScalingStatDistributionID" },
            { false, FT_SHORT, "ItemDelay" },
            { false, FT_SHORT, "PageID" },
            { false, FT_SHORT, "StartQuestID" },
            { false, FT_SHORT, "LockID" },
            { false, FT_SHORT, "RandomSelect" },
            { false, FT_SHORT, "ItemRandomSuffixGroupID" },
            { false, FT_SHORT, "ItemSet" },
            { false, FT_SHORT, "ZoneBound" },
            { false, FT_SHORT, "InstanceBound" },
            { false, FT_SHORT, "TotemCategoryID" },
            { false, FT_SHORT, "SocketMatch_enchantment_id" },
            { false, FT_SHORT, "GemProperties" },
            { false, FT_SHORT, "LimitCategory" },
            { false, FT_SHORT, "RequiredHoliday" },
            { false, FT_SHORT, "RequiredTransmogHoliday" },
            { false, FT_SHORT, "ItemNameDescriptionID" },
            { false, FT_BYTE, "OverallQualityID" },
            { false, FT_BYTE, "InventoryType" },
            { true, FT_BYTE, "RequiredLevel" },
            { false, FT_BYTE, "RequiredPVPRank" },
            { false, FT_BYTE, "RequiredPVPMedal" },
            { false, FT_BYTE, "MinReputation" },
            { false, FT_BYTE, "ContainerSlots" },
            { true, FT_BYTE, "StatModifierBonusStat1" },
            { true, FT_BYTE, "StatModifierBonusStat2" },
            { true, FT_BYTE, "StatModifierBonusStat3" },
            { true, FT_BYTE, "StatModifierBonusStat4" },
            { true, FT_BYTE, "StatModifierBonusStat5" },
            { true, FT_BYTE, "StatModifierBonusStat6" },
            { true, FT_BYTE, "StatModifierBonusStat7" },
            { true, FT_BYTE, "StatModifierBonusStat8" },
            { true, FT_BYTE, "StatModifierBonusStat9" },
            { true, FT_BYTE, "StatModifierBonusStat10" },
            { false, FT_BYTE, "DamageDamageType" },
            { false, FT_BYTE, "Bonding" },
            { false, FT_BYTE, "LanguageID" },
            { false, FT_BYTE, "PageMaterialID" },
            { true, FT_BYTE, "Material" },
            { false, FT_BYTE, "SheatheType" },
            { false, FT_BYTE, "SocketType1" },
            { false, FT_BYTE, "SocketType2" },
            { false, FT_BYTE, "SocketType3" },
            { false, FT_BYTE, "SpellWeightCategory" },
            { false, FT_BYTE, "SpellWeight" },
            { false, FT_BYTE, "ArtifactID" },
            { false, FT_BYTE, "ExpansionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSparseMeta::Instance(), HOTFIX_SEL_ITEM_SPARSE);
        return &loadInfo;
    }
};

struct ItemSpecLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "SpecializationID" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "MaxLevel" },
            { false, FT_BYTE, "ItemType" },
            { false, FT_BYTE, "PrimaryStat" },
            { false, FT_BYTE, "SecondaryStat" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSpecMeta::Instance(), HOTFIX_SEL_ITEM_SPEC);
        return &loadInfo;
    }
};

struct ItemSpecOverrideLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "SpecID" },
            { false, FT_INT, "ItemID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSpecOverrideMeta::Instance(), HOTFIX_SEL_ITEM_SPEC_OVERRIDE);
        return &loadInfo;
    }
};

struct ItemSubClassLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "DisplayName" },
            { false, FT_STRING, "VerboseName" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "ClassID" },
            { false, FT_BYTE, "SubClassID" },
            { false, FT_BYTE, "PrerequisiteProficiency" },
            { false, FT_BYTE, "PostrequisiteProficiency" },
            { false, FT_BYTE, "DisplayFlags" },
            { false, FT_BYTE, "WeaponSwingSize" },
            { false, FT_BYTE, "AuctionHouseSortOrder" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSubClassMeta::Instance(), HOTFIX_SEL_ITEM_SUB_CLASS);
        return &loadInfo;
    }
};

struct ItemSubClassMaskLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "Mask" },
            { false, FT_BYTE, "ClassID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemSubClassMaskMeta::Instance(), HOTFIX_SEL_ITEM_SUB_CLASS_MASK);
        return &loadInfo;
    }
};

struct ItemUpgradeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CurrencyAmount" },
            { false, FT_SHORT, "PrerequisiteID" },
            { false, FT_SHORT, "CurrencyType" },
            { false, FT_BYTE, "ItemUpgradePathID" },
            { false, FT_BYTE, "ItemLevelIncrement" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemUpgradeMeta::Instance(), HOTFIX_SEL_ITEM_UPGRADE);
        return &loadInfo;
    }
};

struct ItemVisualsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ModelFileID1" },
            { true, FT_INT, "ModelFileID2" },
            { true, FT_INT, "ModelFileID3" },
            { true, FT_INT, "ModelFileID4" },
            { true, FT_INT, "ModelFileID5" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemVisualsMeta::Instance(), HOTFIX_SEL_ITEM_VISUALS);
        return &loadInfo;
    }
};

struct ItemXBonusTreeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ItemBonusTreeID" },
            { false, FT_INT, "ItemID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ItemXBonusTreeMeta::Instance(), HOTFIX_SEL_ITEM_X_BONUS_TREE);
        return &loadInfo;
    }
};

struct JournalEncounterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_FLOAT, "Map1" },
            { false, FT_FLOAT, "Map2" },
            { false, FT_SHORT, "DungeonMapID" },
            { false, FT_SHORT, "WorldMapAreaID" },
            { false, FT_SHORT, "FirstSectionID" },
            { false, FT_SHORT, "JournalInstanceID" },
            { false, FT_BYTE, "DifficultyMask" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "OrderIndex" },
            { true, FT_INT, "MapDisplayConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalEncounterMeta::Instance(), HOTFIX_SEL_JOURNAL_ENCOUNTER);
        return &loadInfo;
    }
};

struct JournalEncounterCreatureLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "CreatureDisplayInfoID" },
            { true, FT_INT, "FileDataID" },
            { true, FT_INT, "UiModelSceneID" },
            { false, FT_SHORT, "JournalEncounterID" },
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalEncounterCreatureMeta::Instance(), HOTFIX_SEL_JOURNAL_ENCOUNTER_CREATURE);
        return &loadInfo;
    }
};

struct JournalEncounterItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "JournalEncounterID" },
            { false, FT_BYTE, "DifficultyMask" },
            { false, FT_BYTE, "FactionMask" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalEncounterItemMeta::Instance(), HOTFIX_SEL_JOURNAL_ENCOUNTER_ITEM);
        return &loadInfo;
    }
};

struct JournalEncounterSectionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Title" },
            { false, FT_STRING, "BodyText" },
            { true, FT_INT, "IconCreatureDisplayInfoID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "IconFileDataID" },
            { false, FT_SHORT, "JournalEncounterID" },
            { false, FT_SHORT, "NextSiblingSectionID" },
            { false, FT_SHORT, "FirstChildSectionID" },
            { false, FT_SHORT, "ParentSectionID" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "IconFlags" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "DifficultyMask" },
            { true, FT_INT, "UiModelSceneID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalEncounterSectionMeta::Instance(), HOTFIX_SEL_JOURNAL_ENCOUNTER_SECTION);
        return &loadInfo;
    }
};

struct JournalEncounterXDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "DifficultyID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalEncounterXDifficultyMeta::Instance(), HOTFIX_SEL_JOURNAL_ENCOUNTER_X_DIFFICULTY);
        return &loadInfo;
    }
};

struct JournalEncounterXMapLocLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Map1" },
            { false, FT_FLOAT, "Map2" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "JournalEncounterID" },
            { true, FT_INT, "DungeonMapID" },
            { true, FT_INT, "MapDisplayConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalEncounterXMapLocMeta::Instance(), HOTFIX_SEL_JOURNAL_ENCOUNTER_X_MAP_LOC);
        return &loadInfo;
    }
};

struct JournalInstanceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "ButtonFileDataID" },
            { true, FT_INT, "ButtonSmallFileDataID" },
            { true, FT_INT, "BackgroundFileDataID" },
            { true, FT_INT, "LoreFileDataID" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalInstanceMeta::Instance(), HOTFIX_SEL_JOURNAL_INSTANCE);
        return &loadInfo;
    }
};

struct JournalItemXDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "DifficultyID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalItemXDifficultyMeta::Instance(), HOTFIX_SEL_JOURNAL_ITEM_X_DIFFICULTY);
        return &loadInfo;
    }
};

struct JournalSectionXDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "DifficultyID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalSectionXDifficultyMeta::Instance(), HOTFIX_SEL_JOURNAL_SECTION_X_DIFFICULTY);
        return &loadInfo;
    }
};

struct JournalTierLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalTierMeta::Instance(), HOTFIX_SEL_JOURNAL_TIER);
        return &loadInfo;
    }
};

struct JournalTierXInstanceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "JournalTierID" },
            { false, FT_SHORT, "JournalInstanceID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, JournalTierXInstanceMeta::Instance(), HOTFIX_SEL_JOURNAL_TIER_X_INSTANCE);
        return &loadInfo;
    }
};

struct KeychainLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Key1" },
            { false, FT_BYTE, "Key2" },
            { false, FT_BYTE, "Key3" },
            { false, FT_BYTE, "Key4" },
            { false, FT_BYTE, "Key5" },
            { false, FT_BYTE, "Key6" },
            { false, FT_BYTE, "Key7" },
            { false, FT_BYTE, "Key8" },
            { false, FT_BYTE, "Key9" },
            { false, FT_BYTE, "Key10" },
            { false, FT_BYTE, "Key11" },
            { false, FT_BYTE, "Key12" },
            { false, FT_BYTE, "Key13" },
            { false, FT_BYTE, "Key14" },
            { false, FT_BYTE, "Key15" },
            { false, FT_BYTE, "Key16" },
            { false, FT_BYTE, "Key17" },
            { false, FT_BYTE, "Key18" },
            { false, FT_BYTE, "Key19" },
            { false, FT_BYTE, "Key20" },
            { false, FT_BYTE, "Key21" },
            { false, FT_BYTE, "Key22" },
            { false, FT_BYTE, "Key23" },
            { false, FT_BYTE, "Key24" },
            { false, FT_BYTE, "Key25" },
            { false, FT_BYTE, "Key26" },
            { false, FT_BYTE, "Key27" },
            { false, FT_BYTE, "Key28" },
            { false, FT_BYTE, "Key29" },
            { false, FT_BYTE, "Key30" },
            { false, FT_BYTE, "Key31" },
            { false, FT_BYTE, "Key32" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, KeychainMeta::Instance(), HOTFIX_SEL_KEYCHAIN);
        return &loadInfo;
    }
};

struct KeystoneAffixLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "Filedataid" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, KeystoneAffixMeta::Instance(), HOTFIX_SEL_KEYSTONE_AFFIX);
        return &loadInfo;
    }
};

struct LanguagesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LanguagesMeta::Instance(), HOTFIX_SEL_LANGUAGES);
        return &loadInfo;
    }
};

struct LanguageWordsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Word" },
            { false, FT_BYTE, "LanguageID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LanguageWordsMeta::Instance(), HOTFIX_SEL_LANGUAGE_WORDS);
        return &loadInfo;
    }
};

struct LfgDungeonExpansionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "RandomID" },
            { false, FT_BYTE, "ExpansionLevel" },
            { false, FT_BYTE, "HardLevelMin" },
            { false, FT_BYTE, "HardLevelMax" },
            { true, FT_INT, "TargetLevelMin" },
            { true, FT_INT, "TargetLevelMax" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LFGDungeonExpansionMeta::Instance(), HOTFIX_SEL_LFG_DUNGEON_EXPANSION);
        return &loadInfo;
    }
};

struct LfgDungeonGroupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "OrderIndex" },
            { false, FT_BYTE, "ParentGroupId" },
            { false, FT_BYTE, "Typeid" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LFGDungeonGroupMeta::Instance(), HOTFIX_SEL_LFG_DUNGEON_GROUP);
        return &loadInfo;
    }
};

struct LfgDungeonsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_INT, "Flags" },
            { false, FT_FLOAT, "MinGear" },
            { false, FT_SHORT, "MaxLevel" },
            { false, FT_SHORT, "TargetLevelMax" },
            { true, FT_SHORT, "MapID" },
            { false, FT_SHORT, "RandomID" },
            { false, FT_SHORT, "ScenarioID" },
            { false, FT_SHORT, "FinalEncounterID" },
            { false, FT_SHORT, "BonusReputationAmount" },
            { false, FT_SHORT, "MentorItemLevel" },
            { false, FT_SHORT, "RequiredPlayerConditionId" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "TargetLevel" },
            { false, FT_BYTE, "TargetLevelMin" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "TypeID" },
            { true, FT_BYTE, "Faction" },
            { false, FT_BYTE, "ExpansionLevel" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "GroupID" },
            { false, FT_BYTE, "CountTank" },
            { false, FT_BYTE, "CountHealer" },
            { false, FT_BYTE, "CountDamage" },
            { false, FT_BYTE, "MinCountTank" },
            { false, FT_BYTE, "MinCountHealer" },
            { false, FT_BYTE, "MinCountDamage" },
            { false, FT_BYTE, "Substruct" },
            { false, FT_BYTE, "MentorCharLevel" },
            { true, FT_INT, "IconTextureFileID" },
            { true, FT_INT, "RewardsBgTextureFileID" },
            { true, FT_INT, "PopupBgTextureFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LFGDungeonsMeta::Instance(), HOTFIX_SEL_LFG_DUNGEONS);
        return &loadInfo;
    }
};

struct LfgDungeonsGroupingMapLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "RandomLfgDungeonsID" },
            { false, FT_BYTE, "GroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LfgDungeonsGroupingMapMeta::Instance(), HOTFIX_SEL_LFG_DUNGEONS_GROUPING_MAP);
        return &loadInfo;
    }
};

struct LfgRoleRequirementLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "RoleType" },
            { true, FT_INT, "PlayerConditionID" },
            { false, FT_SHORT, "LfgDungeonsId" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LFGRoleRequirementMeta::Instance(), HOTFIX_SEL_LFG_ROLE_REQUIREMENT);
        return &loadInfo;
    }
};

struct LightLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "GameCoordsX" },
            { false, FT_FLOAT, "GameCoordsY" },
            { false, FT_FLOAT, "GameCoordsZ" },
            { false, FT_FLOAT, "GameFalloffStart" },
            { false, FT_FLOAT, "GameFalloffEnd" },
            { false, FT_SHORT, "ContinentID" },
            { false, FT_SHORT, "LightParamsID1" },
            { false, FT_SHORT, "LightParamsID2" },
            { false, FT_SHORT, "LightParamsID3" },
            { false, FT_SHORT, "LightParamsID4" },
            { false, FT_SHORT, "LightParamsID5" },
            { false, FT_SHORT, "LightParamsID6" },
            { false, FT_SHORT, "LightParamsID7" },
            { false, FT_SHORT, "LightParamsID8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LightMeta::Instance(), HOTFIX_SEL_LIGHT);
        return &loadInfo;
    }
};

struct LightDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "DirectColor" },
            { true, FT_INT, "AmbientColor" },
            { false, FT_INT, "SkyTopColor" },
            { true, FT_INT, "SkyMiddleColor" },
            { true, FT_INT, "SkyBand1Color" },
            { false, FT_INT, "SkyBand2Color" },
            { true, FT_INT, "SkySmogColor" },
            { true, FT_INT, "SkyFogColor" },
            { true, FT_INT, "SunColor" },
            { true, FT_INT, "CloudSunColor" },
            { true, FT_INT, "CloudEmissiveColor" },
            { true, FT_INT, "CloudLayer1AmbientColor" },
            { true, FT_INT, "CloudLayer2AmbientColor" },
            { true, FT_INT, "OceanCloseColor" },
            { true, FT_INT, "OceanFarColor" },
            { true, FT_INT, "RiverCloseColor" },
            { true, FT_INT, "RiverFarColor" },
            { false, FT_INT, "ShadowOpacity" },
            { false, FT_FLOAT, "FogEnd" },
            { false, FT_FLOAT, "FogScaler" },
            { false, FT_FLOAT, "CloudDensity" },
            { false, FT_FLOAT, "FogDensity" },
            { false, FT_FLOAT, "FogHeight" },
            { false, FT_FLOAT, "FogHeightScaler" },
            { false, FT_FLOAT, "FogHeightDensity" },
            { false, FT_FLOAT, "SunFogAngle" },
            { false, FT_FLOAT, "EndFogColorDistance" },
            { true, FT_INT, "SunFogColor" },
            { true, FT_INT, "EndFogColor" },
            { true, FT_INT, "FogHeightColor" },
            { true, FT_INT, "ColorGradingFileDataID" },
            { true, FT_INT, "HorizonAmbientColor" },
            { true, FT_INT, "GroundAmbientColor" },
            { false, FT_SHORT, "LightParamID" },
            { false, FT_SHORT, "Time" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LightDataMeta::Instance(), HOTFIX_SEL_LIGHT_DATA);
        return &loadInfo;
    }
};

struct LightParamsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "Glow" },
            { false, FT_FLOAT, "WaterShallowAlpha" },
            { false, FT_FLOAT, "WaterDeepAlpha" },
            { false, FT_FLOAT, "OceanShallowAlpha" },
            { false, FT_FLOAT, "OceanDeepAlpha" },
            { false, FT_FLOAT, "OverrideCelestialSphere1" },
            { false, FT_FLOAT, "OverrideCelestialSphere2" },
            { false, FT_FLOAT, "OverrideCelestialSphere3" },
            { false, FT_SHORT, "LightSkyboxID" },
            { false, FT_BYTE, "HighlightSky" },
            { false, FT_BYTE, "CloudTypeID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LightParamsMeta::Instance(), HOTFIX_SEL_LIGHT_PARAMS);
        return &loadInfo;
    }
};

struct LightSkyboxLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "CelestialSkyboxFileDataID" },
            { true, FT_INT, "SkyboxFileDataID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LightSkyboxMeta::Instance(), HOTFIX_SEL_LIGHT_SKYBOX);
        return &loadInfo;
    }
};

struct LiquidMaterialLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "LVF" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LiquidMaterialMeta::Instance(), HOTFIX_SEL_LIQUID_MATERIAL);
        return &loadInfo;
    }
};

struct LiquidObjectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "FlowDirection" },
            { false, FT_FLOAT, "FlowSpeed" },
            { false, FT_SHORT, "LiquidTypeID" },
            { false, FT_BYTE, "Fishable" },
            { false, FT_BYTE, "Reflection" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LiquidObjectMeta::Instance(), HOTFIX_SEL_LIQUID_OBJECT);
        return &loadInfo;
    }
};

struct LiquidTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING_NOT_LOCALIZED, "Texture1" },
            { false, FT_STRING_NOT_LOCALIZED, "Texture2" },
            { false, FT_STRING_NOT_LOCALIZED, "Texture3" },
            { false, FT_STRING_NOT_LOCALIZED, "Texture4" },
            { false, FT_STRING_NOT_LOCALIZED, "Texture5" },
            { false, FT_STRING_NOT_LOCALIZED, "Texture6" },
            { false, FT_INT, "SpellID" },
            { false, FT_FLOAT, "MaxDarkenDepth" },
            { false, FT_FLOAT, "FogDarkenIntensity" },
            { false, FT_FLOAT, "AmbDarkenIntensity" },
            { false, FT_FLOAT, "DirDarkenIntensity" },
            { false, FT_FLOAT, "ParticleScale" },
            { false, FT_INT, "Color1" },
            { false, FT_INT, "Color2" },
            { false, FT_FLOAT, "Float1" },
            { false, FT_FLOAT, "Float2" },
            { false, FT_FLOAT, "Float3" },
            { false, FT_FLOAT, "Float4" },
            { false, FT_FLOAT, "Float5" },
            { false, FT_FLOAT, "Float6" },
            { false, FT_FLOAT, "Float7" },
            { false, FT_FLOAT, "Float8" },
            { false, FT_FLOAT, "Float9" },
            { false, FT_FLOAT, "Float10" },
            { false, FT_FLOAT, "Float11" },
            { false, FT_FLOAT, "Float12" },
            { false, FT_FLOAT, "Float13" },
            { false, FT_FLOAT, "Float14" },
            { false, FT_FLOAT, "Float15" },
            { false, FT_FLOAT, "Float16" },
            { false, FT_FLOAT, "Float17" },
            { false, FT_FLOAT, "Float18" },
            { false, FT_INT, "Int1" },
            { false, FT_INT, "Int2" },
            { false, FT_INT, "Int3" },
            { false, FT_INT, "Int4" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "LightID" },
            { false, FT_BYTE, "SoundBank" },
            { false, FT_BYTE, "ParticleMovement" },
            { false, FT_BYTE, "ParticleTexSlots" },
            { false, FT_BYTE, "MaterialID" },
            { false, FT_BYTE, "FrameCountTexture1" },
            { false, FT_BYTE, "FrameCountTexture2" },
            { false, FT_BYTE, "FrameCountTexture3" },
            { false, FT_BYTE, "FrameCountTexture4" },
            { false, FT_BYTE, "FrameCountTexture5" },
            { false, FT_BYTE, "FrameCountTexture6" },
            { true, FT_INT, "SoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LiquidTypeMeta::Instance(), HOTFIX_SEL_LIQUID_TYPE);
        return &loadInfo;
    }
};

struct LoadingScreensLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "NarrowScreenFileDataID" },
            { true, FT_INT, "WideScreenFileDataID" },
            { true, FT_INT, "WideScreen169FileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LoadingScreensMeta::Instance(), HOTFIX_SEL_LOADING_SCREENS);
        return &loadInfo;
    }
};

struct LoadingScreenTaxiSplinesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "LocX1" },
            { false, FT_FLOAT, "LocX2" },
            { false, FT_FLOAT, "LocX3" },
            { false, FT_FLOAT, "LocX4" },
            { false, FT_FLOAT, "LocX5" },
            { false, FT_FLOAT, "LocX6" },
            { false, FT_FLOAT, "LocX7" },
            { false, FT_FLOAT, "LocX8" },
            { false, FT_FLOAT, "LocX9" },
            { false, FT_FLOAT, "LocX10" },
            { false, FT_FLOAT, "LocY1" },
            { false, FT_FLOAT, "LocY2" },
            { false, FT_FLOAT, "LocY3" },
            { false, FT_FLOAT, "LocY4" },
            { false, FT_FLOAT, "LocY5" },
            { false, FT_FLOAT, "LocY6" },
            { false, FT_FLOAT, "LocY7" },
            { false, FT_FLOAT, "LocY8" },
            { false, FT_FLOAT, "LocY9" },
            { false, FT_FLOAT, "LocY10" },
            { false, FT_SHORT, "PathID" },
            { false, FT_SHORT, "LoadingScreenID" },
            { false, FT_BYTE, "LegIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LoadingScreenTaxiSplinesMeta::Instance(), HOTFIX_SEL_LOADING_SCREEN_TAXI_SPLINES);
        return &loadInfo;
    }
};

struct LocaleLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FontFileDataID" },
            { false, FT_BYTE, "WowLocale" },
            { false, FT_BYTE, "Secondary" },
            { false, FT_BYTE, "ClientDisplayExpansion" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LocaleMeta::Instance(), HOTFIX_SEL_LOCALE);
        return &loadInfo;
    }
};

struct LocationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_FLOAT, "Pos3" },
            { false, FT_FLOAT, "Rot1" },
            { false, FT_FLOAT, "Rot2" },
            { false, FT_FLOAT, "Rot3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LocationMeta::Instance(), HOTFIX_SEL_LOCATION);
        return &loadInfo;
    }
};

struct LockLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Index1" },
            { true, FT_INT, "Index2" },
            { true, FT_INT, "Index3" },
            { true, FT_INT, "Index4" },
            { true, FT_INT, "Index5" },
            { true, FT_INT, "Index6" },
            { true, FT_INT, "Index7" },
            { true, FT_INT, "Index8" },
            { false, FT_SHORT, "Skill1" },
            { false, FT_SHORT, "Skill2" },
            { false, FT_SHORT, "Skill3" },
            { false, FT_SHORT, "Skill4" },
            { false, FT_SHORT, "Skill5" },
            { false, FT_SHORT, "Skill6" },
            { false, FT_SHORT, "Skill7" },
            { false, FT_SHORT, "Skill8" },
            { false, FT_BYTE, "Type1" },
            { false, FT_BYTE, "Type2" },
            { false, FT_BYTE, "Type3" },
            { false, FT_BYTE, "Type4" },
            { false, FT_BYTE, "Type5" },
            { false, FT_BYTE, "Type6" },
            { false, FT_BYTE, "Type7" },
            { false, FT_BYTE, "Type8" },
            { false, FT_BYTE, "Action1" },
            { false, FT_BYTE, "Action2" },
            { false, FT_BYTE, "Action3" },
            { false, FT_BYTE, "Action4" },
            { false, FT_BYTE, "Action5" },
            { false, FT_BYTE, "Action6" },
            { false, FT_BYTE, "Action7" },
            { false, FT_BYTE, "Action8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LockMeta::Instance(), HOTFIX_SEL_LOCK);
        return &loadInfo;
    }
};

struct LockTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "ResourceName" },
            { false, FT_STRING, "Verb" },
            { false, FT_STRING, "CursorName" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LockTypeMeta::Instance(), HOTFIX_SEL_LOCK_TYPE);
        return &loadInfo;
    }
};

struct LookAtControllerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ReactionEnableDistance" },
            { false, FT_FLOAT, "ReactionGiveupDistance" },
            { false, FT_FLOAT, "TorsoSpeedFactor" },
            { false, FT_FLOAT, "HeadSpeedFactor" },
            { false, FT_SHORT, "ReactionEnableFOVDeg" },
            { false, FT_SHORT, "ReactionGiveupTimeMS" },
            { false, FT_SHORT, "ReactionIgnoreTimeMinMS" },
            { false, FT_SHORT, "ReactionIgnoreTimeMaxMS" },
            { false, FT_BYTE, "MaxTorsoYaw" },
            { false, FT_BYTE, "MaxTorsoYawWhileMoving" },
            { false, FT_BYTE, "MaxHeadYaw" },
            { false, FT_BYTE, "MaxHeadPitch" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ReactionWarmUpTimeMSMin" },
            { true, FT_INT, "ReactionWarmUpTimeMSMax" },
            { true, FT_INT, "ReactionGiveupFOVDeg" },
            { true, FT_INT, "MaxTorsoPitchUp" },
            { true, FT_INT, "MaxTorsoPitchDown" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, LookAtControllerMeta::Instance(), HOTFIX_SEL_LOOK_AT_CONTROLLER);
        return &loadInfo;
    }
};

struct MailTemplateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Body" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MailTemplateMeta::Instance(), HOTFIX_SEL_MAIL_TEMPLATE);
        return &loadInfo;
    }
};

struct ManagedWorldStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "CurrentStageWorldStateID" },
            { true, FT_INT, "ProgressWorldStateID" },
            { true, FT_INT, "UpTimeSecs" },
            { true, FT_INT, "DownTimeSecs" },
            { true, FT_INT, "OccurrencesWorldStateID" },
            { true, FT_INT, "AccumulationStateTargetValue" },
            { true, FT_INT, "DepletionStateTargetValue" },
            { true, FT_INT, "AccumulationAmountPerMinute" },
            { true, FT_INT, "DepletionAmountPerMinute" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManagedWorldStateMeta::Instance(), HOTFIX_SEL_MANAGED_WORLD_STATE);
        return &loadInfo;
    }
};

struct ManagedWorldStateBuffLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "OccurrenceValue" },
            { true, FT_INT, "BuffSpellID" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "ManagedWorldStateID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManagedWorldStateBuffMeta::Instance(), HOTFIX_SEL_MANAGED_WORLD_STATE_BUFF);
        return &loadInfo;
    }
};

struct ManagedWorldStateInputLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ManagedWorldStateID" },
            { true, FT_INT, "QuestID" },
            { true, FT_INT, "ValidInputConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManagedWorldStateInputMeta::Instance(), HOTFIX_SEL_MANAGED_WORLD_STATE_INPUT);
        return &loadInfo;
    }
};

struct ManifestInterfaceActionIconLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManifestInterfaceActionIconMeta::Instance(), HOTFIX_SEL_MANIFEST_INTERFACE_ACTION_ICON);
        return &loadInfo;
    }
};

struct ManifestInterfaceDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "FilePath" },
            { false, FT_STRING, "FileName" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManifestInterfaceDataMeta::Instance(), HOTFIX_SEL_MANIFEST_INTERFACE_DATA);
        return &loadInfo;
    }
};

struct ManifestInterfaceItemIconLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManifestInterfaceItemIconMeta::Instance(), HOTFIX_SEL_MANIFEST_INTERFACE_ITEM_ICON);
        return &loadInfo;
    }
};

struct ManifestInterfaceTOCDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "FilePath" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManifestInterfaceTOCDataMeta::Instance(), HOTFIX_SEL_MANIFEST_INTERFACE_T_O_C_DATA);
        return &loadInfo;
    }
};

struct ManifestMP3LoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ManifestMP3Meta::Instance(), HOTFIX_SEL_MANIFEST_M_P3);
        return &loadInfo;
    }
};

struct MapLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Directory" },
            { false, FT_STRING, "MapName" },
            { false, FT_STRING, "MapDescription0" },
            { false, FT_STRING, "MapDescription1" },
            { false, FT_STRING, "PvpShortDescription" },
            { false, FT_STRING, "PvpLongDescription" },
            { false, FT_INT, "Flags1" },
            { false, FT_INT, "Flags2" },
            { false, FT_FLOAT, "MinimapIconScale" },
            { false, FT_FLOAT, "CorpsePosX" },
            { false, FT_FLOAT, "CorpsePosY" },
            { false, FT_SHORT, "AreaTableID" },
            { false, FT_SHORT, "LoadingScreenID" },
            { true, FT_SHORT, "CorpseMapID" },
            { false, FT_SHORT, "TimeOfDayOverride" },
            { true, FT_SHORT, "ParentMapID" },
            { true, FT_SHORT, "CosmeticParentMapID" },
            { false, FT_SHORT, "WindSettingsID" },
            { false, FT_BYTE, "InstanceType" },
            { false, FT_BYTE, "MapType" },
            { false, FT_BYTE, "ExpansionID" },
            { false, FT_BYTE, "MaxPlayers" },
            { false, FT_BYTE, "TimeOffset" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapMeta::Instance(), HOTFIX_SEL_MAP);
        return &loadInfo;
    }
};

struct MapCelestialBodyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "CelestialBodyID" },
            { true, FT_INT, "PlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapCelestialBodyMeta::Instance(), HOTFIX_SEL_MAP_CELESTIAL_BODY);
        return &loadInfo;
    }
};

struct MapChallengeModeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "CriteriaCount1" },
            { false, FT_SHORT, "CriteriaCount2" },
            { false, FT_SHORT, "CriteriaCount3" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapChallengeModeMeta::Instance(), HOTFIX_SEL_MAP_CHALLENGE_MODE);
        return &loadInfo;
    }
};

struct MapDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Message" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "ResetInterval" },
            { false, FT_BYTE, "MaxPlayers" },
            { false, FT_BYTE, "LockID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "ItemContext" },
            { true, FT_INT, "ItemContextPickerID" },
            { true, FT_SHORT, "MapID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapDifficultyMeta::Instance(), HOTFIX_SEL_MAP_DIFFICULTY);
        return &loadInfo;
    }
};

struct MapDifficultyXConditionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "FailureDescription" },
            { false, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "OrderIndex" },
            { false, FT_INT, "MapDifficultyId" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapDifficultyXConditionMeta::Instance(), HOTFIX_SEL_MAP_DIFFICULTY_X_CONDITION);
        return &loadInfo;
    }
};

struct MapLoadingScreenLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Min1" },
            { false, FT_FLOAT, "Min2" },
            { false, FT_FLOAT, "Max1" },
            { false, FT_FLOAT, "Max2" },
            { true, FT_INT, "LoadingScreenID" },
            { true, FT_INT, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MapLoadingScreenMeta::Instance(), HOTFIX_SEL_MAP_LOADING_SCREEN);
        return &loadInfo;
    }
};

struct MarketingPromotionsXLocaleLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "AcceptURL" },
            { true, FT_INT, "AdTexture" },
            { true, FT_INT, "LogoTexture" },
            { true, FT_INT, "AcceptButtonTexture" },
            { true, FT_INT, "DeclineButtonTexture" },
            { false, FT_BYTE, "PromotionID" },
            { false, FT_BYTE, "LocaleID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MarketingPromotionsXLocaleMeta::Instance(), HOTFIX_SEL_MARKETING_PROMOTIONS_X);
        return &loadInfo;
    }
};

struct MaterialLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "FoleySoundID" },
            { true, FT_INT, "SheatheSoundID" },
            { true, FT_INT, "UnsheatheSoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MaterialMeta::Instance(), HOTFIX_SEL_MATERIAL);
        return &loadInfo;
    }
};

struct MissileTargetingLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "TurnLingering" },
            { false, FT_FLOAT, "PitchLingering" },
            { false, FT_FLOAT, "MouseLingering" },
            { false, FT_FLOAT, "EndOpacity" },
            { false, FT_FLOAT, "ArcSpeed" },
            { false, FT_FLOAT, "ArcRepeat" },
            { false, FT_FLOAT, "ArcWidth" },
            { false, FT_FLOAT, "ImpactRadius1" },
            { false, FT_FLOAT, "ImpactRadius2" },
            { false, FT_FLOAT, "ImpactTexRadius" },
            { true, FT_INT, "ArcTextureFileID" },
            { true, FT_INT, "ImpactTextureFileID" },
            { true, FT_INT, "ImpactModelFileID1" },
            { true, FT_INT, "ImpactModelFileID2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MissileTargetingMeta::Instance(), HOTFIX_SEL_MISSILE_TARGETING);
        return &loadInfo;
    }
};

struct ModelAnimCloakDampeningLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "AnimationDataID" },
            { true, FT_INT, "CloakDampeningID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ModelAnimCloakDampeningMeta::Instance(), HOTFIX_SEL_MODEL_ANIM_CLOAK_DAMPENING);
        return &loadInfo;
    }
};

struct ModelFileDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "LodCount" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "ModelResourcesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ModelFileDataMeta::Instance(), HOTFIX_SEL_MODEL_FILE_DATA);
        return &loadInfo;
    }
};

struct ModelRibbonQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "RibbonQualityID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ModelRibbonQualityMeta::Instance(), HOTFIX_SEL_MODEL_RIBBON_QUALITY);
        return &loadInfo;
    }
};

struct ModifierTreeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Asset" },
            { true, FT_INT, "SecondaryAsset" },
            { true, FT_INT, "Parent" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "TertiaryAsset" },
            { false, FT_BYTE, "Operator" },
            { false, FT_BYTE, "Amount" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ModifierTreeMeta::Instance(), HOTFIX_SEL_MODIFIER_TREE);
        return &loadInfo;
    }
};

struct MountLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "SourceText" },
            { true, FT_INT, "SourceSpellID" },
            { false, FT_FLOAT, "MountFlyRideHeight" },
            { false, FT_SHORT, "MountTypeID" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "SourceTypeEnum" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "UiModelSceneID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountMeta::Instance(), HOTFIX_SEL_MOUNT);
        return &loadInfo;
    }
};

struct MountCapabilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ReqSpellKnownID" },
            { true, FT_INT, "ModSpellAuraID" },
            { false, FT_SHORT, "ReqRidingSkill" },
            { false, FT_SHORT, "ReqAreaID" },
            { true, FT_SHORT, "ReqMapID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "ReqSpellAuraID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_CAPABILITY);
        return &loadInfo;
    }
};

struct MountTypeXCapabilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MountTypeID" },
            { false, FT_SHORT, "MountCapabilityID" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountTypeXCapabilityMeta::Instance(), HOTFIX_SEL_MOUNT_TYPE_X_CAPABILITY);
        return &loadInfo;
    }
};

struct MountXDisplayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CreatureDisplayInfoID" },
            { true, FT_INT, "PlayerConditionID" },
            { false, FT_INT, "MountID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MountXDisplayMeta::Instance(), HOTFIX_SEL_MOUNT_X_DISPLAY);
        return &loadInfo;
    }
};

struct MovieLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "AudioFileDataID" },
            { true, FT_INT, "SubtitleFileDataID" },
            { false, FT_BYTE, "Volume" },
            { false, FT_BYTE, "KeyID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MovieMeta::Instance(), HOTFIX_SEL_MOVIE);
        return &loadInfo;
    }
};

struct MovieFileDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Resolution" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MovieFileDataMeta::Instance(), HOTFIX_SEL_MOVIE_FILE_DATA);
        return &loadInfo;
    }
};

struct MovieVariationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { true, FT_INT, "OverlayFileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, MovieVariationMeta::Instance(), HOTFIX_SEL_MOVIE_VARIATION);
        return &loadInfo;
    }
};

struct NameGenLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING_NOT_LOCALIZED, "Name" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "Sex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NameGenMeta::Instance(), HOTFIX_SEL_NAME_GEN);
        return &loadInfo;
    }
};

struct NamesProfanityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING_NOT_LOCALIZED, "Name" },
            { true, FT_BYTE, "Language" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NamesProfanityMeta::Instance(), HOTFIX_SEL_NAMES_PROFANITY);
        return &loadInfo;
    }
};

struct NamesReservedLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING_NOT_LOCALIZED, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NamesReservedMeta::Instance(), HOTFIX_SEL_NAMES_RESERVED);
        return &loadInfo;
    }
};

struct NamesReservedLocaleLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING_NOT_LOCALIZED, "Name" },
            { false, FT_BYTE, "LocaleMask" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NamesReservedLocaleMeta::Instance(), HOTFIX_SEL_NAMES_RESERVED);
        return &loadInfo;
    }
};

struct NPCModelItemSlotDisplayInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemDisplayInfoID" },
            { false, FT_BYTE, "ItemSlot" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NPCModelItemSlotDisplayInfoMeta::Instance(), HOTFIX_SEL_N_P_C_MODEL_ITEM_SLOT_DISPLAY_INFO);
        return &loadInfo;
    }
};

struct NPCSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundID1" },
            { true, FT_INT, "SoundID2" },
            { true, FT_INT, "SoundID3" },
            { true, FT_INT, "SoundID4" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, NPCSoundsMeta::Instance(), HOTFIX_SEL_N_P_C_SOUNDS);
        return &loadInfo;
    }
};

struct ObjectEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Offset1" },
            { false, FT_FLOAT, "Offset2" },
            { false, FT_FLOAT, "Offset3" },
            { false, FT_SHORT, "ObjectEffectGroupID" },
            { false, FT_BYTE, "TriggerType" },
            { false, FT_BYTE, "EventType" },
            { false, FT_BYTE, "EffectRecType" },
            { false, FT_BYTE, "Attachment" },
            { true, FT_INT, "EffectRecID" },
            { true, FT_INT, "ObjectEffectModifierID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ObjectEffectMeta::Instance(), HOTFIX_SEL_OBJECT_EFFECT);
        return &loadInfo;
    }
};

struct ObjectEffectModifierLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Param1" },
            { false, FT_FLOAT, "Param2" },
            { false, FT_FLOAT, "Param3" },
            { false, FT_FLOAT, "Param4" },
            { false, FT_BYTE, "InputType" },
            { false, FT_BYTE, "MapType" },
            { false, FT_BYTE, "OutputType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ObjectEffectModifierMeta::Instance(), HOTFIX_SEL_OBJECT_EFFECT_MODIFIER);
        return &loadInfo;
    }
};

struct ObjectEffectPackageElemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ObjectEffectPackageID" },
            { false, FT_SHORT, "ObjectEffectGroupID" },
            { false, FT_SHORT, "StateType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ObjectEffectPackageElemMeta::Instance(), HOTFIX_SEL_OBJECT_EFFECT_PACKAGE_ELEM);
        return &loadInfo;
    }
};

struct OutlineEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Range" },
            { true, FT_INT, "UnitConditionID" },
            { true, FT_INT, "PassiveHighlightColorID" },
            { true, FT_INT, "HighlightColorID" },
            { true, FT_INT, "Priority" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, OutlineEffectMeta::Instance(), HOTFIX_SEL_OUTLINE_EFFECT);
        return &loadInfo;
    }
};

struct OverrideSpellDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Spells1" },
            { true, FT_INT, "Spells2" },
            { true, FT_INT, "Spells3" },
            { true, FT_INT, "Spells4" },
            { true, FT_INT, "Spells5" },
            { true, FT_INT, "Spells6" },
            { true, FT_INT, "Spells7" },
            { true, FT_INT, "Spells8" },
            { true, FT_INT, "Spells9" },
            { true, FT_INT, "Spells10" },
            { false, FT_INT, "PlayerActionBarFileDataID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, OverrideSpellDataMeta::Instance(), HOTFIX_SEL_OVERRIDE_SPELL_DATA);
        return &loadInfo;
    }
};

struct PageTextMaterialLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PageTextMaterialMeta::Instance(), HOTFIX_SEL_PAGE_TEXT_MATERIAL);
        return &loadInfo;
    }
};

struct PaperDollItemFrameLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "ItemButtonName" },
            { false, FT_BYTE, "SlotNumber" },
            { true, FT_INT, "SlotIconFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PaperDollItemFrameMeta::Instance(), HOTFIX_SEL_PAPER_DOLL_ITEM_FRAME);
        return &loadInfo;
    }
};

struct ParagonReputationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "LevelThreshold" },
            { true, FT_INT, "QuestID" },
            { true, FT_INT, "FactionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ParagonReputationMeta::Instance(), HOTFIX_SEL_PARAGON_REPUTATION);
        return &loadInfo;
    }
};

struct ParticleColorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Start1" },
            { false, FT_INT, "Start2" },
            { false, FT_INT, "Start3" },
            { false, FT_INT, "Mid1" },
            { false, FT_INT, "Mid2" },
            { false, FT_INT, "Mid3" },
            { false, FT_INT, "End1" },
            { false, FT_INT, "End2" },
            { false, FT_INT, "End3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ParticleColorMeta::Instance(), HOTFIX_SEL_PARTICLE_COLOR);
        return &loadInfo;
    }
};

struct PathLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "SplineType" },
            { false, FT_BYTE, "Red" },
            { false, FT_BYTE, "Green" },
            { false, FT_BYTE, "Blue" },
            { false, FT_BYTE, "Alpha" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PathMeta::Instance(), HOTFIX_SEL_PATH);
        return &loadInfo;
    }
};

struct PathNodeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "LocationID" },
            { false, FT_SHORT, "PathID" },
            { false, FT_SHORT, "Sequence" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PathNodeMeta::Instance(), HOTFIX_SEL_PATH_NODE);
        return &loadInfo;
    }
};

struct PathNodePropertyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "PathID" },
            { false, FT_SHORT, "Sequence" },
            { false, FT_BYTE, "PropertyIndex" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "Value" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PathNodePropertyMeta::Instance(), HOTFIX_SEL_PATH_NODE_PROPERTY);
        return &loadInfo;
    }
};

struct PathPropertyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "Value" },
            { false, FT_SHORT, "PathID" },
            { false, FT_BYTE, "PropertyIndex" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PathPropertyMeta::Instance(), HOTFIX_SEL_PATH_PROPERTY);
        return &loadInfo;
    }
};

struct PhaseLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PhaseMeta::Instance(), HOTFIX_SEL_PHASE);
        return &loadInfo;
    }
};

struct PhaseShiftZoneSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "PhaseID" },
            { false, FT_SHORT, "PhaseGroupID" },
            { false, FT_SHORT, "SoundAmbienceID" },
            { false, FT_SHORT, "UwSoundAmbienceID" },
            { false, FT_BYTE, "WmoAreaID" },
            { false, FT_BYTE, "PhaseUseFlags" },
            { false, FT_BYTE, "SoundProviderPreferencesID" },
            { false, FT_BYTE, "UwSoundProviderPreferencesID" },
            { true, FT_INT, "ZoneIntroMusicID" },
            { true, FT_INT, "ZoneMusicID" },
            { true, FT_INT, "UwZoneIntroMusicID" },
            { true, FT_INT, "UwZoneMusicID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PhaseShiftZoneSoundsMeta::Instance(), HOTFIX_SEL_PHASE_SHIFT_ZONE_SOUNDS);
        return &loadInfo;
    }
};

struct PhaseXPhaseGroupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "PhaseID" },
            { false, FT_SHORT, "PhaseGroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PhaseXPhaseGroupMeta::Instance(), HOTFIX_SEL_PHASE_X_PHASE_GROUP);
        return &loadInfo;
    }
};

struct PlayerConditionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_LONG, "RaceMask" },
            { false, FT_STRING, "FailureDescription" },
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_SHORT, "MinLevel" },
            { false, FT_SHORT, "MaxLevel" },
            { true, FT_INT, "ClassMask" },
            { true, FT_BYTE, "Gender" },
            { true, FT_BYTE, "NativeGender" },
            { true, FT_INT, "SkillLogic" },
            { false, FT_BYTE, "LanguageID" },
            { false, FT_BYTE, "MinLanguage" },
            { true, FT_INT, "MaxLanguage" },
            { false, FT_SHORT, "MaxFactionID" },
            { false, FT_BYTE, "MaxReputation" },
            { true, FT_INT, "ReputationLogic" },
            { false, FT_BYTE, "CurrentPvpFaction" },
            { false, FT_BYTE, "MinPVPRank" },
            { false, FT_BYTE, "MaxPVPRank" },
            { false, FT_BYTE, "PvpMedal" },
            { true, FT_INT, "PrevQuestLogic" },
            { true, FT_INT, "CurrQuestLogic" },
            { true, FT_INT, "CurrentCompletedQuestLogic" },
            { true, FT_INT, "SpellLogic" },
            { true, FT_INT, "ItemLogic" },
            { false, FT_BYTE, "ItemFlags" },
            { true, FT_INT, "AuraSpellLogic" },
            { false, FT_SHORT, "WorldStateExpressionID" },
            { false, FT_BYTE, "WeatherID" },
            { false, FT_BYTE, "PartyStatus" },
            { false, FT_BYTE, "LifetimeMaxPVPRank" },
            { true, FT_INT, "AchievementLogic" },
            { true, FT_INT, "LfgLogic" },
            { true, FT_INT, "AreaLogic" },
            { true, FT_INT, "CurrencyLogic" },
            { false, FT_SHORT, "QuestKillID" },
            { true, FT_INT, "QuestKillLogic" },
            { true, FT_BYTE, "MinExpansionLevel" },
            { true, FT_BYTE, "MaxExpansionLevel" },
            { true, FT_BYTE, "MinExpansionTier" },
            { true, FT_BYTE, "MaxExpansionTier" },
            { false, FT_BYTE, "MinGuildLevel" },
            { false, FT_BYTE, "MaxGuildLevel" },
            { false, FT_BYTE, "PhaseUseFlags" },
            { false, FT_SHORT, "PhaseID" },
            { true, FT_INT, "PhaseGroupID" },
            { true, FT_INT, "MinAvgItemLevel" },
            { true, FT_INT, "MaxAvgItemLevel" },
            { false, FT_SHORT, "MinAvgEquippedItemLevel" },
            { false, FT_SHORT, "MaxAvgEquippedItemLevel" },
            { true, FT_BYTE, "ChrSpecializationIndex" },
            { true, FT_BYTE, "ChrSpecializationRole" },
            { true, FT_BYTE, "PowerType" },
            { false, FT_BYTE, "PowerTypeComp" },
            { false, FT_BYTE, "PowerTypeValue" },
            { true, FT_INT, "ModifierTreeID" },
            { true, FT_INT, "WeaponSubclassMask" },
            { false, FT_SHORT, "SkillID1" },
            { false, FT_SHORT, "SkillID2" },
            { false, FT_SHORT, "SkillID3" },
            { false, FT_SHORT, "SkillID4" },
            { false, FT_SHORT, "MinSkill1" },
            { false, FT_SHORT, "MinSkill2" },
            { false, FT_SHORT, "MinSkill3" },
            { false, FT_SHORT, "MinSkill4" },
            { false, FT_SHORT, "MaxSkill1" },
            { false, FT_SHORT, "MaxSkill2" },
            { false, FT_SHORT, "MaxSkill3" },
            { false, FT_SHORT, "MaxSkill4" },
            { true, FT_INT, "MinFactionID1" },
            { true, FT_INT, "MinFactionID2" },
            { true, FT_INT, "MinFactionID3" },
            { false, FT_BYTE, "MinReputation1" },
            { false, FT_BYTE, "MinReputation2" },
            { false, FT_BYTE, "MinReputation3" },
            { false, FT_SHORT, "PrevQuestID1" },
            { false, FT_SHORT, "PrevQuestID2" },
            { false, FT_SHORT, "PrevQuestID3" },
            { false, FT_SHORT, "PrevQuestID4" },
            { false, FT_SHORT, "CurrQuestID1" },
            { false, FT_SHORT, "CurrQuestID2" },
            { false, FT_SHORT, "CurrQuestID3" },
            { false, FT_SHORT, "CurrQuestID4" },
            { false, FT_SHORT, "CurrentCompletedQuestID1" },
            { false, FT_SHORT, "CurrentCompletedQuestID2" },
            { false, FT_SHORT, "CurrentCompletedQuestID3" },
            { false, FT_SHORT, "CurrentCompletedQuestID4" },
            { true, FT_INT, "SpellID1" },
            { true, FT_INT, "SpellID2" },
            { true, FT_INT, "SpellID3" },
            { true, FT_INT, "SpellID4" },
            { true, FT_INT, "ItemID1" },
            { true, FT_INT, "ItemID2" },
            { true, FT_INT, "ItemID3" },
            { true, FT_INT, "ItemID4" },
            { true, FT_INT, "ItemCount1" },
            { true, FT_INT, "ItemCount2" },
            { true, FT_INT, "ItemCount3" },
            { true, FT_INT, "ItemCount4" },
            { false, FT_SHORT, "Explored1" },
            { false, FT_SHORT, "Explored2" },
            { true, FT_INT, "Time1" },
            { true, FT_INT, "Time2" },
            { true, FT_INT, "AuraSpellID1" },
            { true, FT_INT, "AuraSpellID2" },
            { true, FT_INT, "AuraSpellID3" },
            { true, FT_INT, "AuraSpellID4" },
            { false, FT_BYTE, "AuraStacks1" },
            { false, FT_BYTE, "AuraStacks2" },
            { false, FT_BYTE, "AuraStacks3" },
            { false, FT_BYTE, "AuraStacks4" },
            { false, FT_SHORT, "Achievement1" },
            { false, FT_SHORT, "Achievement2" },
            { false, FT_SHORT, "Achievement3" },
            { false, FT_SHORT, "Achievement4" },
            { false, FT_BYTE, "LfgStatus1" },
            { false, FT_BYTE, "LfgStatus2" },
            { false, FT_BYTE, "LfgStatus3" },
            { false, FT_BYTE, "LfgStatus4" },
            { false, FT_BYTE, "LfgCompare1" },
            { false, FT_BYTE, "LfgCompare2" },
            { false, FT_BYTE, "LfgCompare3" },
            { false, FT_BYTE, "LfgCompare4" },
            { true, FT_INT, "LfgValue1" },
            { true, FT_INT, "LfgValue2" },
            { true, FT_INT, "LfgValue3" },
            { true, FT_INT, "LfgValue4" },
            { false, FT_SHORT, "AreaID1" },
            { false, FT_SHORT, "AreaID2" },
            { false, FT_SHORT, "AreaID3" },
            { false, FT_SHORT, "AreaID4" },
            { true, FT_INT, "CurrencyID1" },
            { true, FT_INT, "CurrencyID2" },
            { true, FT_INT, "CurrencyID3" },
            { true, FT_INT, "CurrencyID4" },
            { true, FT_INT, "CurrencyCount1" },
            { true, FT_INT, "CurrencyCount2" },
            { true, FT_INT, "CurrencyCount3" },
            { true, FT_INT, "CurrencyCount4" },
            { true, FT_INT, "QuestKillMonster1" },
            { true, FT_INT, "QuestKillMonster2" },
            { true, FT_INT, "QuestKillMonster3" },
            { true, FT_INT, "QuestKillMonster4" },
            { true, FT_INT, "QuestKillMonster5" },
            { true, FT_INT, "QuestKillMonster6" },
            { true, FT_INT, "MovementFlags1" },
            { true, FT_INT, "MovementFlags2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PlayerConditionMeta::Instance(), HOTFIX_SEL_PLAYER_CONDITION);
        return &loadInfo;
    }
};

struct PositionerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "StartLife" },
            { false, FT_SHORT, "FirstStateID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "StartLifePercent" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PositionerMeta::Instance(), HOTFIX_SEL_POSITIONER);
        return &loadInfo;
    }
};

struct PositionerStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "EndLife" },
            { false, FT_BYTE, "EndLifePercent" },
            { true, FT_INT, "NextStateID" },
            { true, FT_INT, "TransformMatrixID" },
            { true, FT_INT, "PosEntryID" },
            { true, FT_INT, "RotEntryID" },
            { true, FT_INT, "ScaleEntryID" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PositionerStateMeta::Instance(), HOTFIX_SEL_POSITIONER_STATE);
        return &loadInfo;
    }
};

struct PositionerStateEntryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ParamA" },
            { false, FT_FLOAT, "ParamB" },
            { false, FT_SHORT, "SrcValType" },
            { false, FT_SHORT, "SrcVal" },
            { false, FT_SHORT, "DstValType" },
            { false, FT_SHORT, "DstVal" },
            { false, FT_BYTE, "EntryType" },
            { false, FT_BYTE, "Style" },
            { false, FT_BYTE, "SrcType" },
            { false, FT_BYTE, "DstType" },
            { true, FT_INT, "CurveID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PositionerStateMeta::Instance(), HOTFIX_SEL_POSITIONER_STATE_ENTRY);
        return &loadInfo;
    }
};

struct PowerDisplayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "GlobalStringBaseTag" },
            { false, FT_BYTE, "ActualType" },
            { false, FT_BYTE, "Red" },
            { false, FT_BYTE, "Green" },
            { false, FT_BYTE, "Blue" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PowerDisplayMeta::Instance(), HOTFIX_SEL_POWER_DISPLAY);
        return &loadInfo;
    }
};

struct PowerTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "NameGlobalStringTag" },
            { false, FT_STRING, "CostGlobalStringTag" },
            { false, FT_FLOAT, "RegenPeace" },
            { false, FT_FLOAT, "RegenCombat" },
            { false, FT_SHORT, "MaxBasePower" },
            { false, FT_SHORT, "RegenInterruptTimeMS" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "PowerTypeEnum" },
            { false, FT_BYTE, "MinPower" },
            { false, FT_BYTE, "CenterPower" },
            { false, FT_BYTE, "DefaultPower" },
            { false, FT_BYTE, "DisplayModifier" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PowerTypeMeta::Instance(), HOTFIX_SEL_POWER_TYPE);
        return &loadInfo;
    }
};

struct PrestigeLevelInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "BadgeTextureFileDataID" },
            { false, FT_BYTE, "PrestigeLevel" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PrestigeLevelInfoMeta::Instance(), HOTFIX_SEL_PRESTIGE_LEVEL_INFO);
        return &loadInfo;
    }
};

struct PvpBracketTypesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "BracketID" },
            { true, FT_INT, "WeeklyQuestID1" },
            { true, FT_INT, "WeeklyQuestID2" },
            { true, FT_INT, "WeeklyQuestID3" },
            { true, FT_INT, "WeeklyQuestID4" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PVPBracketTypesMeta::Instance(), HOTFIX_SEL_PVP_BRACKET_TYPES);
        return &loadInfo;
    }
};

struct PvpDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "RangeIndex" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "MaxLevel" },
            { false, FT_SHORT, "MapID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PVPDifficultyMeta::Instance(), HOTFIX_SEL_PVP_DIFFICULTY);
        return &loadInfo;
    }
};

struct PvpItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
            { false, FT_BYTE, "ItemLevelDelta" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PVPItemMeta::Instance(), HOTFIX_SEL_PVP_ITEM);
        return &loadInfo;
    }
};

struct PvpRewardLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "HonorLevel" },
            { true, FT_INT, "PrestigeLevel" },
            { true, FT_INT, "RewardPackID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpRewardMeta::Instance(), HOTFIX_SEL_PVP_REWARD);
        return &loadInfo;
    }
};

struct PvpScalingEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Value" },
            { true, FT_INT, "PvpScalingEffectTypeID" },
            { true, FT_INT, "SpecializationID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpScalingEffectMeta::Instance(), HOTFIX_SEL_PVP_SCALING_EFFECT);
        return &loadInfo;
    }
};

struct PvpScalingEffectTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpScalingEffectTypeMeta::Instance(), HOTFIX_SEL_PVP_SCALING_EFFECT_TYPE);
        return &loadInfo;
    }
};

struct PvpTalentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { false, FT_INT, "SpellID" },
            { false, FT_INT, "OverrideSpellID" },
            { false, FT_INT, "ExtraSpellID" },
            { false, FT_INT, "TierID" },
            { false, FT_INT, "ColumnIndex" },
            { false, FT_INT, "Flags" },
            { false, FT_INT, "ClassID" },
            { false, FT_INT, "SpecID" },
            { false, FT_INT, "Role" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentMeta::Instance(), HOTFIX_SEL_PVP_TALENT);
        return &loadInfo;
    }
};

struct PvpTalentUnlockLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_INT, "ID" },
            { false, FT_INT, "TierID" },
            { false, FT_INT, "ColumnIndex" },
            { false, FT_INT, "HonorLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, PvpTalentUnlockMeta::Instance(), HOTFIX_SEL_PVP_TALENT_UNLOCK);
        return &loadInfo;
    }
};

struct QuestFactionRewardLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Difficulty1" },
            { false, FT_SHORT, "Difficulty2" },
            { false, FT_SHORT, "Difficulty3" },
            { false, FT_SHORT, "Difficulty4" },
            { false, FT_SHORT, "Difficulty5" },
            { false, FT_SHORT, "Difficulty6" },
            { false, FT_SHORT, "Difficulty7" },
            { false, FT_SHORT, "Difficulty8" },
            { false, FT_SHORT, "Difficulty9" },
            { false, FT_SHORT, "Difficulty10" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestFactionRewardMeta::Instance(), HOTFIX_SEL_QUEST_FACTION_REWARD);
        return &loadInfo;
    }
};

struct QuestFeedbackEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_SHORT, "MinimapAtlasMemberID" },
            { false, FT_BYTE, "AttachPoint" },
            { false, FT_BYTE, "PassiveHighlightColorType" },
            { false, FT_BYTE, "Priority" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestFeedbackEffectMeta::Instance(), HOTFIX_SEL_QUEST_FEEDBACK_EFFECT);
        return &loadInfo;
    }
};

struct QuestInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "InfoName" },
            { false, FT_SHORT, "Profession" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "Modifiers" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestInfoMeta::Instance(), HOTFIX_SEL_QUEST_INFO);
        return &loadInfo;
    }
};

struct QuestLineLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestLineMeta::Instance(), HOTFIX_SEL_QUEST_LINE);
        return &loadInfo;
    }
};

struct QuestLineXQuestLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "QuestLineID" },
            { false, FT_SHORT, "QuestID" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestLineXQuestMeta::Instance(), HOTFIX_SEL_QUEST_LINE_X_QUEST);
        return &loadInfo;
    }
};

struct QuestMoneyRewardLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Difficulty1" },
            { true, FT_INT, "Difficulty2" },
            { true, FT_INT, "Difficulty3" },
            { true, FT_INT, "Difficulty4" },
            { true, FT_INT, "Difficulty5" },
            { true, FT_INT, "Difficulty6" },
            { true, FT_INT, "Difficulty7" },
            { true, FT_INT, "Difficulty8" },
            { true, FT_INT, "Difficulty9" },
            { true, FT_INT, "Difficulty10" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestMoneyRewardMeta::Instance(), HOTFIX_SEL_QUEST_MONEY_REWARD);
        return &loadInfo;
    }
};

struct QuestObjectiveLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "Amount" },
            { true, FT_INT, "ObjectID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "StorageIndex" },
            { false, FT_BYTE, "Flags" },
            { false, FT_SHORT, "QuestID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestObjectiveMeta::Instance(), HOTFIX_SEL_QUEST_OBJECTIVE);
        return &loadInfo;
    }
};

struct QuestPackageItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "PackageID" },
            { false, FT_BYTE, "DisplayType" },
            { true, FT_INT, "ItemQuantity" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestPackageItemMeta::Instance(), HOTFIX_SEL_QUEST_PACKAGE_ITEM);
        return &loadInfo;
    }
};

struct QuestPOIBlobLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "WorldMapAreaID" },
            { false, FT_BYTE, "NumPoints" },
            { false, FT_BYTE, "Floor" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "QuestID" },
            { true, FT_INT, "ObjectiveIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestPOIBlobMeta::Instance(), HOTFIX_SEL_QUEST_P_O_I_BLOB);
        return &loadInfo;
    }
};

struct QuestPOIPointLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_INT, "QuestPOIBlobID" },
            { true, FT_SHORT, "X" },
            { true, FT_SHORT, "Y" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestPOIPointMeta::Instance(), HOTFIX_SEL_QUEST_P_O_I_POINT);
        return &loadInfo;
    }
};

struct QuestSortLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "SortName" },
            { false, FT_BYTE, "UiOrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestSortMeta::Instance(), HOTFIX_SEL_QUEST_SORT);
        return &loadInfo;
    }
};

struct QuestV2LoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "UniqueBitFlag" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestV2Meta::Instance(), HOTFIX_SEL_QUEST_V2);
        return &loadInfo;
    }
};

struct QuestV2CliTaskLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_LONG, "FiltRaces" },
            { false, FT_STRING, "QuestTitle" },
            { false, FT_STRING, "BulletText" },
            { true, FT_INT, "StartItem" },
            { false, FT_SHORT, "UniqueBitFlag" },
            { false, FT_SHORT, "ConditionID" },
            { false, FT_SHORT, "FiltClasses" },
            { false, FT_SHORT, "FiltCompletedQuest1" },
            { false, FT_SHORT, "FiltCompletedQuest2" },
            { false, FT_SHORT, "FiltCompletedQuest3" },
            { false, FT_SHORT, "FiltMinSkillID" },
            { false, FT_SHORT, "WorldStateExpressionID" },
            { false, FT_BYTE, "FiltActiveQuest" },
            { false, FT_BYTE, "FiltCompletedQuestLogic" },
            { false, FT_BYTE, "FiltMaxFactionID" },
            { false, FT_BYTE, "FiltMaxFactionValue" },
            { true, FT_BYTE, "FiltMaxLevel" },
            { false, FT_BYTE, "FiltMinFactionID" },
            { false, FT_BYTE, "FiltMinFactionValue" },
            { true, FT_BYTE, "FiltMinLevel" },
            { false, FT_BYTE, "FiltMinSkillValue" },
            { false, FT_BYTE, "FiltNonActiveQuest" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "BreadCrumbID" },
            { true, FT_INT, "QuestInfoID" },
            { true, FT_INT, "SandboxScalingID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestV2CliTaskMeta::Instance(), HOTFIX_SEL_QUEST_V2_CLI_TASK);
        return &loadInfo;
    }
};

struct QuestXGroupActivityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "QuestID" },
            { true, FT_INT, "GroupFinderActivityID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestXGroupActivityMeta::Instance(), HOTFIX_SEL_QUEST_X_GROUP_ACTIVITY);
        return &loadInfo;
    }
};

struct QuestXpLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Difficulty1" },
            { false, FT_SHORT, "Difficulty2" },
            { false, FT_SHORT, "Difficulty3" },
            { false, FT_SHORT, "Difficulty4" },
            { false, FT_SHORT, "Difficulty5" },
            { false, FT_SHORT, "Difficulty6" },
            { false, FT_SHORT, "Difficulty7" },
            { false, FT_SHORT, "Difficulty8" },
            { false, FT_SHORT, "Difficulty9" },
            { false, FT_SHORT, "Difficulty10" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, QuestXPMeta::Instance(), HOTFIX_SEL_QUEST_XP);
        return &loadInfo;
    }
};

struct RandPropPointsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Epic1" },
            { true, FT_INT, "Epic2" },
            { true, FT_INT, "Epic3" },
            { true, FT_INT, "Epic4" },
            { true, FT_INT, "Epic5" },
            { true, FT_INT, "Superior1" },
            { true, FT_INT, "Superior2" },
            { true, FT_INT, "Superior3" },
            { true, FT_INT, "Superior4" },
            { true, FT_INT, "Superior5" },
            { true, FT_INT, "Good1" },
            { true, FT_INT, "Good2" },
            { true, FT_INT, "Good3" },
            { true, FT_INT, "Good4" },
            { true, FT_INT, "Good5" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RandPropPointsMeta::Instance(), HOTFIX_SEL_RAND_PROP_POINTS);
        return &loadInfo;
    }
};

struct RelicSlotTierRequirementLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "PlayerConditionID" },
            { false, FT_BYTE, "RelicIndex" },
            { false, FT_BYTE, "RelicTier" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RelicSlotTierRequirementMeta::Instance(), HOTFIX_SEL_RELIC_SLOT_TIER_REQUIREMENT);
        return &loadInfo;
    }
};

struct RelicTalentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ArtifactPowerID" },
            { false, FT_BYTE, "ArtifactPowerLabel" },
            { true, FT_INT, "Type" },
            { true, FT_INT, "PVal" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RelicTalentMeta::Instance(), HOTFIX_SEL_RELIC_TALENT);
        return &loadInfo;
    }
};

struct ResearchBranchLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "CurrencyID" },
            { false, FT_BYTE, "ResearchFieldID" },
            { true, FT_INT, "TextureFileID" },
            { true, FT_INT, "BigTextureFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ResearchBranchMeta::Instance(), HOTFIX_SEL_RESEARCH_BRANCH);
        return &loadInfo;
    }
};

struct ResearchFieldLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Slot" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ResearchFieldMeta::Instance(), HOTFIX_SEL_RESEARCH_FIELD);
        return &loadInfo;
    }
};

struct ResearchProjectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "ResearchBranchID" },
            { false, FT_BYTE, "Rarity" },
            { false, FT_BYTE, "NumSockets" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "TextureFileID" },
            { true, FT_INT, "RequiredWeight" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ResearchProjectMeta::Instance(), HOTFIX_SEL_RESEARCH_PROJECT);
        return &loadInfo;
    }
};

struct ResearchSiteLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "QuestPoiBlobID" },
            { true, FT_SHORT, "MapID" },
            { true, FT_INT, "AreaPOIIconEnum" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ResearchSiteMeta::Instance(), HOTFIX_SEL_RESEARCH_SITE);
        return &loadInfo;
    }
};

struct ResistancesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "FizzleSoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ResistancesMeta::Instance(), HOTFIX_SEL_RESISTANCES);
        return &loadInfo;
    }
};

struct RewardPackLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Money" },
            { false, FT_FLOAT, "ArtifactXPMultiplier" },
            { false, FT_BYTE, "ArtifactXPDifficulty" },
            { false, FT_BYTE, "ArtifactXPCategoryID" },
            { true, FT_INT, "CharTitleID" },
            { true, FT_INT, "TreasurePickerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RewardPackMeta::Instance(), HOTFIX_SEL_REWARD_PACK);
        return &loadInfo;
    }
};

struct RewardPackXCurrencyTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CurrencyTypeID" },
            { true, FT_INT, "Quantity" },
            { false, FT_INT, "RewardPackID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RewardPackXCurrencyTypeMeta::Instance(), HOTFIX_SEL_REWARD_PACK_X_CURRENCY_TYPE);
        return &loadInfo;
    }
};

struct RewardPackXItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
            { true, FT_INT, "ItemQuantity" },
            { false, FT_INT, "RewardPackID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RewardPackXItemMeta::Instance(), HOTFIX_SEL_REWARD_PACK_X_ITEM);
        return &loadInfo;
    }
};

struct RibbonQualityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "MaxSampleTimeDelta" },
            { false, FT_FLOAT, "AngleThreshold" },
            { false, FT_FLOAT, "MinDistancePerSlice" },
            { false, FT_BYTE, "NumStrips" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RibbonQualityMeta::Instance(), HOTFIX_SEL_RIBBON_QUALITY);
        return &loadInfo;
    }
};

struct RulesetItemUpgradeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ItemID" },
            { false, FT_SHORT, "ItemUpgradeID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, RulesetItemUpgradeMeta::Instance(), HOTFIX_SEL_RULESET_ITEM_UPGRADE);
        return &loadInfo;
    }
};

struct SandboxScalingLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "MinLevel" },
            { false, FT_INT, "MaxLevel" },
            { false, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SandboxScalingMeta::Instance(), HOTFIX_SEL_SANDBOX_SCALING);
        return &loadInfo;
    }
};

struct ScalingStatDistributionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "PlayerLevelToItemLevelCurveID" },
            { false, FT_INT, "MinLevel" },
            { false, FT_INT, "MaxLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScalingStatDistributionMeta::Instance(), HOTFIX_SEL_SCALING_STAT_DISTRIBUTION);
        return &loadInfo;
    }
};

struct ScenarioLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "AreaTableID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "Type" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScenarioMeta::Instance(), HOTFIX_SEL_SCENARIO);
        return &loadInfo;
    }
};

struct ScenarioStepLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "Title" },
            { false, FT_SHORT, "ScenarioID" },
            { false, FT_SHORT, "Supersedes" },
            { false, FT_SHORT, "RewardQuestID" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "Criteriatreeid" },
            { true, FT_INT, "RelatedStep" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScenarioStepMeta::Instance(), HOTFIX_SEL_SCENARIO_STEP);
        return &loadInfo;
    }
};

struct SceneScriptLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "FirstSceneScriptID" },
            { false, FT_SHORT, "NextSceneScriptID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SceneScriptMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT);
        return &loadInfo;
    }
};

struct SceneScriptGlobalTextLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Script" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SceneScriptGlobalTextMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT_GLOBAL_TEXT);
        return &loadInfo;
    }
};

struct SceneScriptPackageLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SceneScriptPackageMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT_PACKAGE);
        return &loadInfo;
    }
};

struct SceneScriptPackageMemberLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "SceneScriptPackageID" },
            { false, FT_SHORT, "SceneScriptID" },
            { false, FT_SHORT, "ChildSceneScriptPackageID" },
            { false, FT_BYTE, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SceneScriptPackageMemberMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT_PACKAGE_MEMBER);
        return &loadInfo;
    }
};

struct SceneScriptTextLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Script" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SceneScriptTextMeta::Instance(), HOTFIX_SEL_SCENE_SCRIPT_TEXT);
        return &loadInfo;
    }
};

struct ScheduledIntervalLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "RepeatType" },
            { true, FT_INT, "DurationSecs" },
            { true, FT_INT, "OffsetSecs" },
            { true, FT_INT, "DateAlignmentType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScheduledIntervalMeta::Instance(), HOTFIX_SEL_SCHEDULED_INTERVAL);
        return &loadInfo;
    }
};

struct ScheduledWorldStateLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ScheduledWorldStateGroupID" },
            { true, FT_INT, "WorldStateID" },
            { true, FT_INT, "Value" },
            { true, FT_INT, "DurationSecs" },
            { true, FT_INT, "Weight" },
            { true, FT_INT, "UniqueCategory" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "OrderIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScheduledWorldStateMeta::Instance(), HOTFIX_SEL_SCHEDULED_WORLD_STATE);
        return &loadInfo;
    }
};

struct ScheduledWorldStateGroupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "ScheduledIntervalID" },
            { true, FT_INT, "SelectionType" },
            { true, FT_INT, "SelectionCount" },
            { true, FT_INT, "Priority" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScheduledWorldStateGroupMeta::Instance(), HOTFIX_SEL_SCHEDULED_WORLD_STATE_GROUP);
        return &loadInfo;
    }
};

struct ScheduledWorldStateXUniqCatLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ScheduledUniqueCategoryID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScheduledWorldStateXUniqCatMeta::Instance(), HOTFIX_SEL_SCHEDULED_WORLD_STATE_X_UNIQ_CAT);
        return &loadInfo;
    }
};

struct ScreenEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_INT, "Param1" },
            { false, FT_INT, "Param2" },
            { false, FT_INT, "Param3" },
            { false, FT_INT, "Param4" },
            { false, FT_SHORT, "LightParamsID" },
            { false, FT_SHORT, "LightParamsFadeIn" },
            { false, FT_SHORT, "LightParamsFadeOut" },
            { false, FT_SHORT, "TimeOfDayOverride" },
            { false, FT_BYTE, "Effect" },
            { false, FT_BYTE, "LightFlags" },
            { false, FT_BYTE, "EffectMask" },
            { true, FT_INT, "FullScreenEffectID" },
            { true, FT_INT, "SoundAmbienceID" },
            { true, FT_INT, "ZoneMusicID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScreenEffectMeta::Instance(), HOTFIX_SEL_SCREEN_EFFECT);
        return &loadInfo;
    }
};

struct ScreenLocationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ScreenLocationMeta::Instance(), HOTFIX_SEL_SCREEN_LOCATION);
        return &loadInfo;
    }
};

struct SDReplacementModelLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SdFileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SDReplacementModelMeta::Instance(), HOTFIX_SEL_S_D_REPLACEMENT_MODEL);
        return &loadInfo;
    }
};

struct SeamlessSiteLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "MapID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SeamlessSiteMeta::Instance(), HOTFIX_SEL_SEAMLESS_SITE);
        return &loadInfo;
    }
};

struct ServerMessagesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ServerMessagesMeta::Instance(), HOTFIX_SEL_SERVER_MESSAGES);
        return &loadInfo;
    }
};

struct ShadowyEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "PrimaryColor" },
            { false, FT_INT, "SecondaryColor" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_FLOAT, "Value" },
            { false, FT_FLOAT, "FadeInTime" },
            { false, FT_FLOAT, "FadeOutTime" },
            { false, FT_FLOAT, "InnerStrength" },
            { false, FT_FLOAT, "OuterStrength" },
            { false, FT_FLOAT, "InitialDelay" },
            { false, FT_BYTE, "AttachPos" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "CurveID" },
            { true, FT_INT, "Priority" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ShadowyEffectMeta::Instance(), HOTFIX_SEL_SHADOWY_EFFECT);
        return &loadInfo;
    }
};

struct SkillLineLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "DisplayName" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "AlternateVerb" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "CategoryID" },
            { false, FT_BYTE, "CanLink" },
            { true, FT_INT, "SpellIconFileID" },
            { true, FT_INT, "ParentSkillLineID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillLineMeta::Instance(), HOTFIX_SEL_SKILL_LINE);
        return &loadInfo;
    }
};

struct SkillLineAbilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_LONG, "RaceMask" },
            { true, FT_INT, "ID" },
            { false, FT_INT, "Spell" },
            { false, FT_INT, "SupercedesSpell" },
            { false, FT_SHORT, "SkillLine" },
            { false, FT_SHORT, "TrivialSkillLineRankHigh" },
            { false, FT_SHORT, "TrivialSkillLineRankLow" },
            { false, FT_SHORT, "UniqueBit" },
            { false, FT_SHORT, "TradeSkillCategoryID" },
            { false, FT_BYTE, "NumSkillUps" },
            { true, FT_INT, "ClassMask" },
            { false, FT_SHORT, "MinSkillLineRank" },
            { false, FT_BYTE, "AcquireMethod" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillLineAbilityMeta::Instance(), HOTFIX_SEL_SKILL_LINE_ABILITY);
        return &loadInfo;
    }
};

struct SkillRaceClassInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_LONG, "RaceMask" },
            { false, FT_SHORT, "SkillID" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "SkillTierID" },
            { false, FT_BYTE, "Availability" },
            { false, FT_BYTE, "MinLevel" },
            { true, FT_INT, "ClassMask" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SkillRaceClassInfoMeta::Instance(), HOTFIX_SEL_SKILL_RACE_CLASS_INFO);
        return &loadInfo;
    }
};

struct SoundAmbienceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "SoundFilterID" },
            { true, FT_INT, "FlavorSoundFilterID" },
            { true, FT_INT, "AmbienceID1" },
            { true, FT_INT, "AmbienceID2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundAmbienceMeta::Instance(), HOTFIX_SEL_SOUND_AMBIENCE);
        return &loadInfo;
    }
};

struct SoundAmbienceFlavorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundEntriesIDDay" },
            { true, FT_INT, "SoundEntriesIDNight" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundAmbienceFlavorMeta::Instance(), HOTFIX_SEL_SOUND_AMBIENCE_FLAVOR);
        return &loadInfo;
    }
};

struct SoundBusLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "DefaultVolume" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "DefaultPlaybackLimit" },
            { false, FT_BYTE, "DefaultPriority" },
            { false, FT_BYTE, "DefaultPriorityPenalty" },
            { false, FT_BYTE, "BusEnumID" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundBusMeta::Instance(), HOTFIX_SEL_SOUND_BUS);
        return &loadInfo;
    }
};

struct SoundBusOverrideLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Volume" },
            { false, FT_BYTE, "PlaybackLimit" },
            { false, FT_BYTE, "Priority" },
            { false, FT_BYTE, "PriorityPenalty" },
            { true, FT_INT, "SoundBusID" },
            { true, FT_INT, "PlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundBusOverrideMeta::Instance(), HOTFIX_SEL_SOUND_BUS_OVERRIDE);
        return &loadInfo;
    }
};

struct SoundEmitterPillPointsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Position1" },
            { false, FT_FLOAT, "Position2" },
            { false, FT_FLOAT, "Position3" },
            { false, FT_SHORT, "SoundEmittersID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundEmitterPillPointsMeta::Instance(), HOTFIX_SEL_SOUND_EMITTER_PILL_POINTS);
        return &loadInfo;
    }
};

struct SoundEmittersLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "Position1" },
            { false, FT_FLOAT, "Position2" },
            { false, FT_FLOAT, "Position3" },
            { false, FT_FLOAT, "Direction1" },
            { false, FT_FLOAT, "Direction2" },
            { false, FT_FLOAT, "Direction3" },
            { false, FT_SHORT, "WorldStateExpressionID" },
            { false, FT_SHORT, "PhaseID" },
            { false, FT_BYTE, "EmitterType" },
            { false, FT_BYTE, "PhaseUseFlags" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundEntriesID" },
            { true, FT_INT, "PhaseGroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundEmittersMeta::Instance(), HOTFIX_SEL_SOUND_EMITTERS);
        return &loadInfo;
    }
};

struct SoundEnvelopeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundKitID" },
            { true, FT_INT, "CurveID" },
            { false, FT_SHORT, "DecayIndex" },
            { false, FT_SHORT, "SustainIndex" },
            { false, FT_SHORT, "ReleaseIndex" },
            { false, FT_BYTE, "EnvelopeType" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundEnvelopeMeta::Instance(), HOTFIX_SEL_SOUND_ENVELOPE);
        return &loadInfo;
    }
};

struct SoundFilterLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundFilterMeta::Instance(), HOTFIX_SEL_SOUND_FILTER);
        return &loadInfo;
    }
};

struct SoundFilterElemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Params1" },
            { false, FT_FLOAT, "Params2" },
            { false, FT_FLOAT, "Params3" },
            { false, FT_FLOAT, "Params4" },
            { false, FT_FLOAT, "Params5" },
            { false, FT_FLOAT, "Params6" },
            { false, FT_FLOAT, "Params7" },
            { false, FT_FLOAT, "Params8" },
            { false, FT_FLOAT, "Params9" },
            { false, FT_BYTE, "FilterType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundFilterElemMeta::Instance(), HOTFIX_SEL_SOUND_FILTER_ELEM);
        return &loadInfo;
    }
};

struct SoundKitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "VolumeFloat" },
            { false, FT_FLOAT, "MinDistance" },
            { false, FT_FLOAT, "DistanceCutoff" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "SoundEntriesAdvancedID" },
            { false, FT_BYTE, "SoundType" },
            { false, FT_BYTE, "DialogType" },
            { false, FT_BYTE, "EAXDef" },
            { false, FT_FLOAT, "VolumeVariationPlus" },
            { false, FT_FLOAT, "VolumeVariationMinus" },
            { false, FT_FLOAT, "PitchVariationPlus" },
            { false, FT_FLOAT, "PitchVariationMinus" },
            { false, FT_FLOAT, "PitchAdjust" },
            { false, FT_SHORT, "BusOverwriteID" },
            { false, FT_BYTE, "MaxInstances" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundKitMeta::Instance(), HOTFIX_SEL_SOUND_KIT);
        return &loadInfo;
    }
};

struct SoundKitAdvancedLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "InnerRadius2D" },
            { false, FT_FLOAT, "DuckToSFX" },
            { false, FT_FLOAT, "DuckToMusic" },
            { false, FT_FLOAT, "InnerRadiusOfInfluence" },
            { false, FT_FLOAT, "OuterRadiusOfInfluence" },
            { true, FT_INT, "TimeToDuck" },
            { true, FT_INT, "TimeToUnduck" },
            { false, FT_FLOAT, "OuterRadius2D" },
            { false, FT_BYTE, "Usage" },
            { true, FT_INT, "SoundKitID" },
            { true, FT_INT, "TimeA" },
            { true, FT_INT, "TimeB" },
            { true, FT_INT, "TimeC" },
            { true, FT_INT, "TimeD" },
            { true, FT_INT, "RandomOffsetRange" },
            { true, FT_INT, "TimeIntervalMin" },
            { true, FT_INT, "TimeIntervalMax" },
            { true, FT_INT, "DelayMin" },
            { true, FT_INT, "DelayMax" },
            { false, FT_BYTE, "VolumeSliderCategory" },
            { false, FT_FLOAT, "DuckToAmbience" },
            { false, FT_FLOAT, "InsideAngle" },
            { false, FT_FLOAT, "OutsideAngle" },
            { false, FT_FLOAT, "OutsideVolume" },
            { false, FT_BYTE, "MinRandomPosOffset" },
            { false, FT_SHORT, "MaxRandomPosOffset" },
            { false, FT_FLOAT, "DuckToDialog" },
            { false, FT_FLOAT, "DuckToSuppressors" },
            { true, FT_INT, "MsOffset" },
            { true, FT_INT, "TimeCooldownMin" },
            { true, FT_INT, "TimeCooldownMax" },
            { false, FT_BYTE, "MaxInstancesBehavior" },
            { false, FT_BYTE, "VolumeControlType" },
            { true, FT_INT, "VolumeFadeInTimeMin" },
            { true, FT_INT, "VolumeFadeInTimeMax" },
            { true, FT_INT, "VolumeFadeInCurveID" },
            { true, FT_INT, "VolumeFadeOutTimeMin" },
            { true, FT_INT, "VolumeFadeOutTimeMax" },
            { true, FT_INT, "VolumeFadeOutCurveID" },
            { false, FT_FLOAT, "ChanceToPlay" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundKitAdvancedMeta::Instance(), HOTFIX_SEL_SOUND_KIT_ADVANCED);
        return &loadInfo;
    }
};

struct SoundKitChildLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ParentSoundKitID" },
            { true, FT_INT, "SoundKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundKitChildMeta::Instance(), HOTFIX_SEL_SOUND_KIT_CHILD);
        return &loadInfo;
    }
};

struct SoundKitEntryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundKitID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_BYTE, "Frequency" },
            { false, FT_FLOAT, "Volume" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundKitMeta::Instance(), HOTFIX_SEL_SOUND_KIT_ENTRY);
        return &loadInfo;
    }
};

struct SoundKitFallbackLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundKitID" },
            { true, FT_INT, "FallbackSoundKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundKitFallbackMeta::Instance(), HOTFIX_SEL_SOUND_KIT_FALLBACK);
        return &loadInfo;
    }
};

struct SoundKitNameLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundKitNameMeta::Instance(), HOTFIX_SEL_SOUND_KIT_NAME);
        return &loadInfo;
    }
};

struct SoundOverrideLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ZoneIntroMusicID" },
            { false, FT_SHORT, "ZoneMusicID" },
            { false, FT_SHORT, "SoundAmbienceID" },
            { false, FT_BYTE, "SoundProviderPreferencesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundOverrideMeta::Instance(), HOTFIX_SEL_SOUND_OVERRIDE);
        return &loadInfo;
    }
};

struct SoundProviderPreferencesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { false, FT_FLOAT, "EAXDecayTime" },
            { false, FT_FLOAT, "EAX2EnvironmentSize" },
            { false, FT_FLOAT, "EAX2EnvironmentDiffusion" },
            { false, FT_FLOAT, "EAX2DecayHFRatio" },
            { false, FT_FLOAT, "EAX2ReflectionsDelay" },
            { false, FT_FLOAT, "EAX2ReverbDelay" },
            { false, FT_FLOAT, "EAX2RoomRolloff" },
            { false, FT_FLOAT, "EAX2AirAbsorption" },
            { false, FT_FLOAT, "EAX3DecayLFRatio" },
            { false, FT_FLOAT, "EAX3EchoTime" },
            { false, FT_FLOAT, "EAX3EchoDepth" },
            { false, FT_FLOAT, "EAX3ModulationTime" },
            { false, FT_FLOAT, "EAX3ModulationDepth" },
            { false, FT_FLOAT, "EAX3HFReference" },
            { false, FT_FLOAT, "EAX3LFReference" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "EAX2Room" },
            { false, FT_SHORT, "EAX2RoomHF" },
            { false, FT_SHORT, "EAX2Reflections" },
            { false, FT_SHORT, "EAX2Reverb" },
            { false, FT_BYTE, "EAXEnvironmentSelection" },
            { false, FT_BYTE, "EAX3RoomLF" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SoundProviderPreferencesMeta::Instance(), HOTFIX_SEL_SOUND_PROVIDER_PREFERENCES);
        return &loadInfo;
    }
};

struct SourceInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "SourceText" },
            { false, FT_BYTE, "SourceTypeEnum" },
            { false, FT_BYTE, "PvpFaction" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SourceInfoMeta::Instance(), HOTFIX_SEL_SOURCE_INFO);
        return &loadInfo;
    }
};

struct SpamMessagesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Text" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpamMessagesMeta::Instance(), HOTFIX_SEL_SPAM_MESSAGES);
        return &loadInfo;
    }
};

struct SpecializationSpellsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Description" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "OverridesSpellID" },
            { false, FT_SHORT, "SpecID" },
            { false, FT_BYTE, "DisplayOrder" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpecializationSpellsMeta::Instance(), HOTFIX_SEL_SPECIALIZATION_SPELLS);
        return &loadInfo;
    }
};

struct SpellActionBarPrefLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "PreferredActionBarMask" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellActionBarPrefMeta::Instance(), HOTFIX_SEL_SPELL_ACTION_BAR_PREF);
        return &loadInfo;
    }
};

struct SpellActivationOverlayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "OverlayFileDataID" },
            { false, FT_INT, "Color" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_INT, "IconHighlightSpellClassMask1" },
            { false, FT_INT, "IconHighlightSpellClassMask2" },
            { false, FT_INT, "IconHighlightSpellClassMask3" },
            { false, FT_INT, "IconHighlightSpellClassMask4" },
            { false, FT_BYTE, "ScreenLocationID" },
            { false, FT_BYTE, "TriggerType" },
            { true, FT_INT, "SoundEntriesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellActivationOverlayMeta::Instance(), HOTFIX_SEL_SPELL_ACTIVATION_OVERLAY);
        return &loadInfo;
    }
};

struct SpellAuraOptionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "ProcCharges" },
            { false, FT_INT, "ProcTypeMask" },
            { true, FT_INT, "ProcCategoryRecovery" },
            { false, FT_SHORT, "CumulativeAura" },
            { false, FT_SHORT, "SpellProcsPerMinuteID" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "ProcChance" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraOptionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_OPTIONS);
        return &loadInfo;
    }
};

struct SpellAuraRestrictionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CasterAuraSpell" },
            { true, FT_INT, "TargetAuraSpell" },
            { true, FT_INT, "ExcludeCasterAuraSpell" },
            { true, FT_INT, "ExcludeTargetAuraSpell" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "CasterAuraState" },
            { false, FT_BYTE, "TargetAuraState" },
            { false, FT_BYTE, "ExcludeCasterAuraState" },
            { false, FT_BYTE, "ExcludeTargetAuraState" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_AURA_RESTRICTIONS);
        return &loadInfo;
    }
};

struct SpellAuraVisibilityLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraVisibilityMeta::Instance(), HOTFIX_SEL_SPELL_AURA_VISIBILITY);
        return &loadInfo;
    }
};

struct SpellAuraVisXChrSpecLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ChrSpecializationID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellAuraVisXChrSpecMeta::Instance(), HOTFIX_SEL_SPELL_AURA_VIS_X_CHR_SPEC);
        return &loadInfo;
    }
};

struct SpellCastingRequirementsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "MinFactionID" },
            { true, FT_SHORT, "RequiredAreasID" },
            { false, FT_SHORT, "RequiresSpellFocus" },
            { false, FT_BYTE, "FacingCasterFlags" },
            { false, FT_BYTE, "MinReputation" },
            { false, FT_BYTE, "RequiredAuraVision" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCastingRequirementsMeta::Instance(), HOTFIX_SEL_SPELL_CASTING_REQUIREMENTS);
        return &loadInfo;
    }
};

struct SpellCastTimesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Base" },
            { true, FT_INT, "Minimum" },
            { true, FT_SHORT, "PerLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCastTimesMeta::Instance(), HOTFIX_SEL_SPELL_CAST_TIMES);
        return &loadInfo;
    }
};

struct SpellCategoriesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "Category" },
            { false, FT_SHORT, "StartRecoveryCategory" },
            { false, FT_SHORT, "ChargeCategory" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "DefenseType" },
            { false, FT_BYTE, "DispelType" },
            { false, FT_BYTE, "Mechanic" },
            { false, FT_BYTE, "PreventionType" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCategoriesMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORIES);
        return &loadInfo;
    }
};

struct SpellCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ChargeRecoveryTime" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "UsesPerWeek" },
            { false, FT_BYTE, "MaxCharges" },
            { true, FT_INT, "TypeMask" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCategoryMeta::Instance(), HOTFIX_SEL_SPELL_CATEGORY);
        return &loadInfo;
    }
};

struct SpellChainEffectsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "AvgSegLen" },
            { false, FT_FLOAT, "NoiseScale" },
            { false, FT_FLOAT, "TexCoordScale" },
            { true, FT_INT, "SegDuration" },
            { true, FT_INT, "Flags" },
            { false, FT_FLOAT, "JointOffsetRadius" },
            { false, FT_FLOAT, "MinorJointScale" },
            { false, FT_FLOAT, "MajorJointScale" },
            { false, FT_FLOAT, "JointMoveSpeed" },
            { false, FT_FLOAT, "JointSmoothness" },
            { false, FT_FLOAT, "MinDurationBetweenJointJumps" },
            { false, FT_FLOAT, "MaxDurationBetweenJointJumps" },
            { false, FT_FLOAT, "WaveHeight" },
            { false, FT_FLOAT, "WaveFreq" },
            { false, FT_FLOAT, "WaveSpeed" },
            { false, FT_FLOAT, "MinWaveAngle" },
            { false, FT_FLOAT, "MaxWaveAngle" },
            { false, FT_FLOAT, "MinWaveSpin" },
            { false, FT_FLOAT, "MaxWaveSpin" },
            { false, FT_FLOAT, "ArcHeight" },
            { false, FT_FLOAT, "MinArcAngle" },
            { false, FT_FLOAT, "MaxArcAngle" },
            { false, FT_FLOAT, "MinArcSpin" },
            { false, FT_FLOAT, "MaxArcSpin" },
            { false, FT_FLOAT, "DelayBetweenEffects" },
            { false, FT_FLOAT, "MinFlickerOnDuration" },
            { false, FT_FLOAT, "MaxFlickerOnDuration" },
            { false, FT_FLOAT, "MinFlickerOffDuration" },
            { false, FT_FLOAT, "MaxFlickerOffDuration" },
            { false, FT_FLOAT, "PulseSpeed" },
            { false, FT_FLOAT, "PulseOnLength" },
            { false, FT_FLOAT, "PulseFadeLength" },
            { false, FT_FLOAT, "WavePhase" },
            { false, FT_FLOAT, "TimePerFlipFrame" },
            { false, FT_FLOAT, "VariancePerFlipFrame" },
            { false, FT_FLOAT, "TextureCoordScaleU1" },
            { false, FT_FLOAT, "TextureCoordScaleU2" },
            { false, FT_FLOAT, "TextureCoordScaleU3" },
            { false, FT_FLOAT, "TextureCoordScaleV1" },
            { false, FT_FLOAT, "TextureCoordScaleV2" },
            { false, FT_FLOAT, "TextureCoordScaleV3" },
            { false, FT_FLOAT, "TextureRepeatLengthU1" },
            { false, FT_FLOAT, "TextureRepeatLengthU2" },
            { false, FT_FLOAT, "TextureRepeatLengthU3" },
            { false, FT_FLOAT, "TextureRepeatLengthV1" },
            { false, FT_FLOAT, "TextureRepeatLengthV2" },
            { false, FT_FLOAT, "TextureRepeatLengthV3" },
            { true, FT_INT, "TextureParticleFileDataID" },
            { false, FT_FLOAT, "StartWidth" },
            { false, FT_FLOAT, "EndWidth" },
            { false, FT_FLOAT, "ParticleScaleMultiplier" },
            { false, FT_FLOAT, "ParticleEmissionRateMultiplier" },
            { false, FT_SHORT, "SegDelay" },
            { false, FT_SHORT, "JointCount" },
            { false, FT_SHORT, "SpellChainEffectID1" },
            { false, FT_SHORT, "SpellChainEffectID2" },
            { false, FT_SHORT, "SpellChainEffectID3" },
            { false, FT_SHORT, "SpellChainEffectID4" },
            { false, FT_SHORT, "SpellChainEffectID5" },
            { false, FT_SHORT, "SpellChainEffectID6" },
            { false, FT_SHORT, "SpellChainEffectID7" },
            { false, FT_SHORT, "SpellChainEffectID8" },
            { false, FT_SHORT, "SpellChainEffectID9" },
            { false, FT_SHORT, "SpellChainEffectID10" },
            { false, FT_SHORT, "SpellChainEffectID11" },
            { false, FT_SHORT, "WidthScaleCurveID" },
            { false, FT_BYTE, "JointsPerMinorJoint" },
            { false, FT_BYTE, "MinorJointsPerMajorJoint" },
            { false, FT_BYTE, "Alpha" },
            { false, FT_BYTE, "Red" },
            { false, FT_BYTE, "Green" },
            { false, FT_BYTE, "Blue" },
            { false, FT_BYTE, "BlendMode" },
            { false, FT_BYTE, "RenderLayer" },
            { false, FT_BYTE, "NumFlipFramesU" },
            { false, FT_BYTE, "NumFlipFramesV" },
            { true, FT_INT, "SoundKitID" },
            { true, FT_INT, "TextureFileDataID1" },
            { true, FT_INT, "TextureFileDataID2" },
            { true, FT_INT, "TextureFileDataID3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellChainEffectsMeta::Instance(), HOTFIX_SEL_SPELL_CHAIN_EFFECTS);
        return &loadInfo;
    }
};

struct SpellClassOptionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_INT, "SpellClassMask1" },
            { false, FT_INT, "SpellClassMask2" },
            { false, FT_INT, "SpellClassMask3" },
            { false, FT_INT, "SpellClassMask4" },
            { false, FT_BYTE, "SpellClassSet" },
            { true, FT_INT, "ModalNextSpell" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellClassOptionsMeta::Instance(), HOTFIX_SEL_SPELL_CLASS_OPTIONS);
        return &loadInfo;
    }
};

struct SpellCooldownsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "CategoryRecoveryTime" },
            { true, FT_INT, "RecoveryTime" },
            { true, FT_INT, "StartRecoveryTime" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellCooldownsMeta::Instance(), HOTFIX_SEL_SPELL_COOLDOWNS);
        return &loadInfo;
    }
};

struct SpellDescriptionVariablesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Variables" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellDescriptionVariablesMeta::Instance(), HOTFIX_SEL_SPELL_DESCRIPTION_VARIABLES);
        return &loadInfo;
    }
};

struct SpellDispelTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "InternalName" },
            { false, FT_BYTE, "Mask" },
            { false, FT_BYTE, "ImmunityPossible" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellDispelTypeMeta::Instance(), HOTFIX_SEL_SPELL_DISPEL_TYPE);
        return &loadInfo;
    }
};

struct SpellDurationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Duration" },
            { true, FT_INT, "MaxDuration" },
            { true, FT_INT, "DurationPerLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellDurationMeta::Instance(), HOTFIX_SEL_SPELL_DURATION);
        return &loadInfo;
    }
};

struct SpellEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Effect" },
            { true, FT_INT, "EffectBasePoints" },
            { true, FT_INT, "EffectIndex" },
            { true, FT_INT, "EffectAura" },
            { true, FT_INT, "DifficultyID" },
            { false, FT_FLOAT, "EffectAmplitude" },
            { true, FT_INT, "EffectAuraPeriod" },
            { false, FT_FLOAT, "EffectBonusCoefficient" },
            { false, FT_FLOAT, "EffectChainAmplitude" },
            { true, FT_INT, "EffectChainTargets" },
            { true, FT_INT, "EffectDieSides" },
            { true, FT_INT, "EffectItemType" },
            { true, FT_INT, "EffectMechanic" },
            { false, FT_FLOAT, "EffectPointsPerResource" },
            { false, FT_FLOAT, "EffectRealPointsPerLevel" },
            { true, FT_INT, "EffectTriggerSpell" },
            { false, FT_FLOAT, "EffectPosFacing" },
            { true, FT_INT, "EffectAttributes" },
            { false, FT_FLOAT, "BonusCoefficientFromAP" },
            { false, FT_FLOAT, "PvpMultiplier" },
            { false, FT_FLOAT, "Coefficient" },
            { false, FT_FLOAT, "Variance" },
            { false, FT_FLOAT, "ResourceCoefficient" },
            { false, FT_FLOAT, "GroupSizeBasePointsCoefficient" },
            { false, FT_INT, "EffectSpellClassMask1" },
            { false, FT_INT, "EffectSpellClassMask2" },
            { false, FT_INT, "EffectSpellClassMask3" },
            { false, FT_INT, "EffectSpellClassMask4" },
            { true, FT_INT, "EffectMiscValue1" },
            { true, FT_INT, "EffectMiscValue2" },
            { true, FT_INT, "EffectRadiusIndex1" },
            { true, FT_INT, "EffectRadiusIndex2" },
            { true, FT_INT, "ImplicitTarget1" },
            { true, FT_INT, "ImplicitTarget2" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEffectMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT);
        return &loadInfo;
    }
};

struct SpellLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "NameSubtext" },
            { false, FT_STRING, "Description" },
            { false, FT_STRING, "AuraDescription" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMeta::Instance(), HOTFIX_SEL_SPELL);
        return &loadInfo;
    }
};

struct SpellEffectEmissionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "EmissionRate" },
            { false, FT_FLOAT, "ModelScale" },
            { false, FT_SHORT, "AreaModelID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEffectEmissionMeta::Instance(), HOTFIX_SEL_SPELL_EFFECT_EMISSION);
        return &loadInfo;
    }
};

struct SpellEquippedItemsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "EquippedItemInvTypes" },
            { true, FT_INT, "EquippedItemSubclass" },
            { false, FT_BYTE, "EquippedItemClass" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellEquippedItemsMeta::Instance(), HOTFIX_SEL_SPELL_EQUIPPED_ITEMS);
        return &loadInfo;
    }
};

struct SpellFlyoutLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_LONG, "RaceMask" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Description" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ClassMask" },
            { true, FT_INT, "SpellIconFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellFlyoutMeta::Instance(), HOTFIX_SEL_SPELL_FLYOUT);
        return &loadInfo;
    }
};

struct SpellFlyoutItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_BYTE, "Slot" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellFlyoutItemMeta::Instance(), HOTFIX_SEL_SPELL_FLYOUT_ITEM);
        return &loadInfo;
    }
};

struct SpellFocusObjectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellFocusObjectMeta::Instance(), HOTFIX_SEL_SPELL_FOCUS_OBJECT);
        return &loadInfo;
    }
};

struct SpellInterruptsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_SHORT, "InterruptFlags" },
            { true, FT_INT, "AuraInterruptFlags1" },
            { true, FT_INT, "AuraInterruptFlags2" },
            { true, FT_INT, "ChannelInterruptFlags1" },
            { true, FT_INT, "ChannelInterruptFlags2" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellInterruptsMeta::Instance(), HOTFIX_SEL_SPELL_INTERRUPTS);
        return &loadInfo;
    }
};

struct SpellItemEnchantmentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_INT, "EffectArg1" },
            { false, FT_INT, "EffectArg2" },
            { false, FT_INT, "EffectArg3" },
            { false, FT_FLOAT, "EffectScalingPoints1" },
            { false, FT_FLOAT, "EffectScalingPoints2" },
            { false, FT_FLOAT, "EffectScalingPoints3" },
            { false, FT_INT, "TransmogCost" },
            { false, FT_INT, "TextureFileDataID" },
            { false, FT_SHORT, "EffectPointsMin1" },
            { false, FT_SHORT, "EffectPointsMin2" },
            { false, FT_SHORT, "EffectPointsMin3" },
            { false, FT_SHORT, "ItemVisual" },
            { false, FT_SHORT, "Flags" },
            { false, FT_SHORT, "RequiredSkillID" },
            { false, FT_SHORT, "RequiredSkillRank" },
            { false, FT_SHORT, "ItemLevel" },
            { false, FT_BYTE, "Charges" },
            { false, FT_BYTE, "Effect1" },
            { false, FT_BYTE, "Effect2" },
            { false, FT_BYTE, "Effect3" },
            { false, FT_BYTE, "ConditionID" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "MaxLevel" },
            { true, FT_BYTE, "ScalingClass" },
            { true, FT_BYTE, "ScalingClassRestricted" },
            { true, FT_INT, "TransmogPlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellItemEnchantmentMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT);
        return &loadInfo;
    }
};

struct SpellItemEnchantmentConditionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "LtOperand1" },
            { true, FT_INT, "LtOperand2" },
            { true, FT_INT, "LtOperand3" },
            { true, FT_INT, "LtOperand4" },
            { true, FT_INT, "LtOperand5" },
            { false, FT_BYTE, "LtOperandType1" },
            { false, FT_BYTE, "LtOperandType2" },
            { false, FT_BYTE, "LtOperandType3" },
            { false, FT_BYTE, "LtOperandType4" },
            { false, FT_BYTE, "LtOperandType5" },
            { false, FT_BYTE, "Operator1" },
            { false, FT_BYTE, "Operator2" },
            { false, FT_BYTE, "Operator3" },
            { false, FT_BYTE, "Operator4" },
            { false, FT_BYTE, "Operator5" },
            { false, FT_BYTE, "RtOperandType1" },
            { false, FT_BYTE, "RtOperandType2" },
            { false, FT_BYTE, "RtOperandType3" },
            { false, FT_BYTE, "RtOperandType4" },
            { false, FT_BYTE, "RtOperandType5" },
            { false, FT_BYTE, "RtOperand1" },
            { false, FT_BYTE, "RtOperand2" },
            { false, FT_BYTE, "RtOperand3" },
            { false, FT_BYTE, "RtOperand4" },
            { false, FT_BYTE, "RtOperand5" },
            { false, FT_BYTE, "Logic1" },
            { false, FT_BYTE, "Logic2" },
            { false, FT_BYTE, "Logic3" },
            { false, FT_BYTE, "Logic4" },
            { false, FT_BYTE, "Logic5" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellItemEnchantmentConditionMeta::Instance(), HOTFIX_SEL_SPELL_ITEM_ENCHANTMENT_CONDITION);
        return &loadInfo;
    }
};

struct SpellKeyboundOverrideLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Function" },
            { true, FT_INT, "Data" },
            { false, FT_BYTE, "Type" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellKeyboundOverrideMeta::Instance(), HOTFIX_SEL_SPELL_KEYBOUND_OVERRIDE);
        return &loadInfo;
    }
};

struct SpellLabelLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "LabelID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellLabelMeta::Instance(), HOTFIX_SEL_SPELL_LABEL);
        return &loadInfo;
    }
};

struct SpellLearnSpellLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "LearnSpellID" },
            { true, FT_INT, "OverridesSpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellLearnSpellMeta::Instance(), HOTFIX_SEL_SPELL_LEARN_SPELL);
        return &loadInfo;
    }
};

struct SpellLevelsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "BaseLevel" },
            { false, FT_SHORT, "MaxLevel" },
            { false, FT_SHORT, "SpellLevel" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "MaxPassiveAuraLevel" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellLevelsMeta::Instance(), HOTFIX_SEL_SPELL_LEVELS);
        return &loadInfo;
    }
};

struct SpellMechanicLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "StateName" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMechanicMeta::Instance(), HOTFIX_SEL_SPELL_MECHANIC);
        return &loadInfo;
    }
};

struct SpellMiscLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "CastingTimeIndex" },
            { false, FT_SHORT, "DurationIndex" },
            { false, FT_SHORT, "RangeIndex" },
            { false, FT_BYTE, "SchoolMask" },
            { true, FT_INT, "SpellIconFileDataID" },
            { false, FT_FLOAT, "Speed" },
            { true, FT_INT, "ActiveIconFileDataID" },
            { false, FT_FLOAT, "LaunchDelay" },
            { false, FT_BYTE, "DifficultyID" },
            { true, FT_INT, "Attributes1" },
            { true, FT_INT, "Attributes2" },
            { true, FT_INT, "Attributes3" },
            { true, FT_INT, "Attributes4" },
            { true, FT_INT, "Attributes5" },
            { true, FT_INT, "Attributes6" },
            { true, FT_INT, "Attributes7" },
            { true, FT_INT, "Attributes8" },
            { true, FT_INT, "Attributes9" },
            { true, FT_INT, "Attributes10" },
            { true, FT_INT, "Attributes11" },
            { true, FT_INT, "Attributes12" },
            { true, FT_INT, "Attributes13" },
            { true, FT_INT, "Attributes14" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMiscMeta::Instance(), HOTFIX_SEL_SPELL_MISC);
        return &loadInfo;
    }
};

struct SpellMissileLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_FLOAT, "DefaultPitchMin" },
            { false, FT_FLOAT, "DefaultPitchMax" },
            { false, FT_FLOAT, "DefaultSpeedMin" },
            { false, FT_FLOAT, "DefaultSpeedMax" },
            { false, FT_FLOAT, "RandomizeFacingMin" },
            { false, FT_FLOAT, "RandomizeFacingMax" },
            { false, FT_FLOAT, "RandomizePitchMin" },
            { false, FT_FLOAT, "RandomizePitchMax" },
            { false, FT_FLOAT, "RandomizeSpeedMin" },
            { false, FT_FLOAT, "RandomizeSpeedMax" },
            { false, FT_FLOAT, "Gravity" },
            { false, FT_FLOAT, "MaxDuration" },
            { false, FT_FLOAT, "CollisionRadius" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMissileMeta::Instance(), HOTFIX_SEL_SPELL_MISSILE);
        return &loadInfo;
    }
};

struct SpellMissileMotionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "ScriptBody" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "MissileCount" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellMissileMotionMeta::Instance(), HOTFIX_SEL_SPELL_MISSILE_MOTION);
        return &loadInfo;
    }
};

struct SpellPowerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ManaCost" },
            { false, FT_FLOAT, "PowerCostPct" },
            { false, FT_FLOAT, "PowerPctPerSecond" },
            { true, FT_INT, "RequiredAuraSpellID" },
            { false, FT_FLOAT, "PowerCostMaxPct" },
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_BYTE, "PowerType" },
            { true, FT_INT, "ID" },
            { false, FT_INT, "ManaCostPerLevel" },
            { true, FT_INT, "ManaPerSecond" },
            { true, FT_INT, "OptionalCost" },
            { true, FT_INT, "PowerDisplayID" },
            { true, FT_INT, "AltPowerBarID" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellPowerMeta::Instance(), HOTFIX_SEL_SPELL_POWER);
        return &loadInfo;
    }
};

struct SpellPowerDifficultyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "OrderIndex" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellPowerDifficultyMeta::Instance(), HOTFIX_SEL_SPELL_POWER_DIFFICULTY);
        return &loadInfo;
    }
};

struct SpellProceduralEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "Value1" },
            { false, FT_FLOAT, "Value2" },
            { false, FT_FLOAT, "Value3" },
            { false, FT_FLOAT, "Value4" },
            { false, FT_BYTE, "Type" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellProceduralEffectMeta::Instance(), HOTFIX_SEL_SPELL_PROCEDURAL_EFFECT);
        return &loadInfo;
    }
};

struct SpellProcsPerMinuteLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "BaseProcRate" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellProcsPerMinuteMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE);
        return &loadInfo;
    }
};

struct SpellProcsPerMinuteModLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Coeff" },
            { false, FT_SHORT, "Param" },
            { false, FT_BYTE, "Type" },
            { false, FT_SHORT, "SpellProcsPerMinuteID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellProcsPerMinuteModMeta::Instance(), HOTFIX_SEL_SPELL_PROCS_PER_MINUTE_MOD);
        return &loadInfo;
    }
};

struct SpellRadiusLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Radius" },
            { false, FT_FLOAT, "RadiusPerLevel" },
            { false, FT_FLOAT, "RadiusMin" },
            { false, FT_FLOAT, "RadiusMax" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellRadiusMeta::Instance(), HOTFIX_SEL_SPELL_RADIUS);
        return &loadInfo;
    }
};

struct SpellRangeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "DisplayName" },
            { false, FT_STRING, "DisplayNameShort" },
            { false, FT_FLOAT, "RangeMin1" },
            { false, FT_FLOAT, "RangeMin2" },
            { false, FT_FLOAT, "RangeMax1" },
            { false, FT_FLOAT, "RangeMax2" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellRangeMeta::Instance(), HOTFIX_SEL_SPELL_RANGE);
        return &loadInfo;
    }
};

struct SpellReagentsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "Reagent1" },
            { true, FT_INT, "Reagent2" },
            { true, FT_INT, "Reagent3" },
            { true, FT_INT, "Reagent4" },
            { true, FT_INT, "Reagent5" },
            { true, FT_INT, "Reagent6" },
            { true, FT_INT, "Reagent7" },
            { true, FT_INT, "Reagent8" },
            { false, FT_SHORT, "ReagentCount1" },
            { false, FT_SHORT, "ReagentCount2" },
            { false, FT_SHORT, "ReagentCount3" },
            { false, FT_SHORT, "ReagentCount4" },
            { false, FT_SHORT, "ReagentCount5" },
            { false, FT_SHORT, "ReagentCount6" },
            { false, FT_SHORT, "ReagentCount7" },
            { false, FT_SHORT, "ReagentCount8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellReagentsMeta::Instance(), HOTFIX_SEL_SPELL_REAGENTS);
        return &loadInfo;
    }
};

struct SpellReagentsCurrencyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "CurrencyTypesID" },
            { false, FT_SHORT, "CurrencyCount" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellReagentsCurrencyMeta::Instance(), HOTFIX_SEL_SPELL_REAGENTS_CURRENCY);
        return &loadInfo;
    }
};

struct SpellScalingLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_SHORT, "ScalesFromItemLevel" },
            { true, FT_INT, "Class" },
            { true, FT_INT, "MinScalingLevel" },
            { true, FT_INT, "MaxScalingLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellScalingMeta::Instance(), HOTFIX_SEL_SPELL_SCALING);
        return &loadInfo;
    }
};

struct SpellShapeshiftLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { false, FT_INT, "ShapeshiftExclude1" },
            { false, FT_INT, "ShapeshiftExclude2" },
            { false, FT_INT, "ShapeshiftMask1" },
            { false, FT_INT, "ShapeshiftMask2" },
            { true, FT_BYTE, "StanceBarOrder" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellShapeshiftMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT);
        return &loadInfo;
    }
};

struct SpellShapeshiftFormLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "DamageVariance" },
            { true, FT_INT, "Flags" },
            { false, FT_SHORT, "CombatRoundTime" },
            { false, FT_SHORT, "MountTypeID" },
            { true, FT_BYTE, "CreatureType" },
            { false, FT_BYTE, "BonusActionBar" },
            { true, FT_INT, "AttackIconFileID" },
            { true, FT_INT, "CreatureDisplayID1" },
            { true, FT_INT, "CreatureDisplayID2" },
            { true, FT_INT, "CreatureDisplayID3" },
            { true, FT_INT, "CreatureDisplayID4" },
            { true, FT_INT, "PresetSpellID1" },
            { true, FT_INT, "PresetSpellID2" },
            { true, FT_INT, "PresetSpellID3" },
            { true, FT_INT, "PresetSpellID4" },
            { true, FT_INT, "PresetSpellID5" },
            { true, FT_INT, "PresetSpellID6" },
            { true, FT_INT, "PresetSpellID7" },
            { true, FT_INT, "PresetSpellID8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellShapeshiftFormMeta::Instance(), HOTFIX_SEL_SPELL_SHAPESHIFT_FORM);
        return &loadInfo;
    }
};

struct SpellSpecialUnitEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "SpellVisualEffectNameID" },
            { true, FT_INT, "PositionerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellSpecialUnitEffectMeta::Instance(), HOTFIX_SEL_SPELL_SPECIAL_UNIT_EFFECT);
        return &loadInfo;
    }
};

struct SpellTargetRestrictionsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ConeDegrees" },
            { false, FT_FLOAT, "Width" },
            { true, FT_INT, "Targets" },
            { false, FT_SHORT, "TargetCreatureType" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "MaxTargets" },
            { true, FT_INT, "MaxTargetLevel" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellTargetRestrictionsMeta::Instance(), HOTFIX_SEL_SPELL_TARGET_RESTRICTIONS);
        return &loadInfo;
    }
};

struct SpellTotemsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "Totem1" },
            { true, FT_INT, "Totem2" },
            { false, FT_SHORT, "RequiredTotemCategoryID1" },
            { false, FT_SHORT, "RequiredTotemCategoryID2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellTotemsMeta::Instance(), HOTFIX_SEL_SPELL_TOTEMS);
        return &loadInfo;
    }
};

struct SpellVisualLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "MissileCastOffset1" },
            { false, FT_FLOAT, "MissileCastOffset2" },
            { false, FT_FLOAT, "MissileCastOffset3" },
            { false, FT_FLOAT, "MissileImpactOffset1" },
            { false, FT_FLOAT, "MissileImpactOffset2" },
            { false, FT_FLOAT, "MissileImpactOffset3" },
            { true, FT_INT, "Flags" },
            { false, FT_SHORT, "SpellVisualMissileSetID" },
            { false, FT_BYTE, "MissileDestinationAttachment" },
            { false, FT_BYTE, "MissileAttachment" },
            { true, FT_INT, "MissileCastPositionerID" },
            { true, FT_INT, "MissileImpactPositionerID" },
            { true, FT_INT, "MissileTargetingKit" },
            { true, FT_INT, "AnimEventSoundID" },
            { false, FT_SHORT, "DamageNumberDelay" },
            { true, FT_INT, "HostileSpellVisualID" },
            { true, FT_INT, "CasterSpellVisualID" },
            { true, FT_INT, "LowViolenceSpellVisualID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL);
        return &loadInfo;
    }
};

struct SpellVisualAnimLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "InitialAnimID" },
            { false, FT_SHORT, "LoopAnimID" },
            { false, FT_SHORT, "AnimKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualAnimMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_ANIM);
        return &loadInfo;
    }
};

struct SpellVisualColorEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_INT, "Color" },
            { false, FT_FLOAT, "ColorMultiplier" },
            { false, FT_SHORT, "RedCurveID" },
            { false, FT_SHORT, "GreenCurveID" },
            { false, FT_SHORT, "BlueCurveID" },
            { false, FT_SHORT, "AlphaCurveID" },
            { false, FT_SHORT, "OpacityCurveID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "Type" },
            { true, FT_INT, "PositionerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualColorEffectMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_COLOR_EFFECT);
        return &loadInfo;
    }
};

struct SpellVisualEffectNameLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ModelFileDataID" },
            { false, FT_FLOAT, "EffectRadius" },
            { false, FT_FLOAT, "BaseMissileSpeed" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_FLOAT, "MinAllowedScale" },
            { false, FT_FLOAT, "MaxAllowedScale" },
            { false, FT_FLOAT, "Alpha" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "Type" },
            { true, FT_INT, "GenericID" },
            { true, FT_INT, "TextureFileDataID" },
            { true, FT_INT, "RibbonQualityID" },
            { true, FT_INT, "DissolveEffectID" },
            { true, FT_INT, "Unknown13" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualEffectNameMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_EFFECT_NAME);
        return &loadInfo;
    }
};

struct SpellVisualEventLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "StartEvent" },
            { true, FT_INT, "StartMinOffsetMs" },
            { true, FT_INT, "StartMaxOffsetMs" },
            { true, FT_INT, "EndEvent" },
            { true, FT_INT, "EndMinOffsetMs" },
            { true, FT_INT, "EndMaxOffsetMs" },
            { true, FT_INT, "TargetType" },
            { true, FT_INT, "SpellVisualKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualEventMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_EVENT);
        return &loadInfo;
    }
};

struct SpellVisualKitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Flags" },
            { false, FT_FLOAT, "FallbackPriority" },
            { true, FT_INT, "FallbackSpellVisualKitID" },
            { false, FT_SHORT, "DelayMin" },
            { false, FT_SHORT, "DelayMax" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualKitMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_KIT);
        return &loadInfo;
    }
};

struct SpellVisualKitAreaModelLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ModelFileDataID" },
            { false, FT_FLOAT, "EmissionRate" },
            { false, FT_FLOAT, "Spacing" },
            { false, FT_FLOAT, "ModelScale" },
            { false, FT_SHORT, "LifeTime" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualKitAreaModelMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_KIT_AREA_MODEL);
        return &loadInfo;
    }
};

struct SpellVisualKitEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "EffectType" },
            { true, FT_INT, "Effect" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualKitEffectMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_KIT_EFFECT);
        return &loadInfo;
    }
};

struct SpellVisualKitModelAttachLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "Offset1" },
            { false, FT_FLOAT, "Offset2" },
            { false, FT_FLOAT, "Offset3" },
            { false, FT_FLOAT, "OffsetVariation1" },
            { false, FT_FLOAT, "OffsetVariation2" },
            { false, FT_FLOAT, "OffsetVariation3" },
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "SpellVisualEffectNameID" },
            { false, FT_BYTE, "AttachmentID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_SHORT, "PositionerID" },
            { false, FT_FLOAT, "Yaw" },
            { false, FT_FLOAT, "Pitch" },
            { false, FT_FLOAT, "Roll" },
            { false, FT_FLOAT, "YawVariation" },
            { false, FT_FLOAT, "PitchVariation" },
            { false, FT_FLOAT, "RollVariation" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_FLOAT, "ScaleVariation" },
            { false, FT_SHORT, "StartAnimID" },
            { false, FT_SHORT, "AnimID" },
            { false, FT_SHORT, "EndAnimID" },
            { false, FT_SHORT, "AnimKitID" },
            { true, FT_INT, "LowDefModelAttachID" },
            { false, FT_FLOAT, "StartDelay" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualKitModelAttachMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_KIT_MODEL_ATTACH);
        return &loadInfo;
    }
};

struct SpellVisualMissileLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_INT, "FollowGroundHeight" },
            { true, FT_INT, "FollowGroundDropSpeed" },
            { true, FT_INT, "Flags" },
            { false, FT_FLOAT, "CastOffset1" },
            { false, FT_FLOAT, "CastOffset2" },
            { false, FT_FLOAT, "CastOffset3" },
            { false, FT_FLOAT, "ImpactOffset1" },
            { false, FT_FLOAT, "ImpactOffset2" },
            { false, FT_FLOAT, "ImpactOffset3" },
            { false, FT_SHORT, "SpellVisualEffectNameID" },
            { false, FT_SHORT, "CastPositionerID" },
            { false, FT_SHORT, "ImpactPositionerID" },
            { false, FT_SHORT, "FollowGroundApproach" },
            { false, FT_SHORT, "SpellMissileMotionID" },
            { false, FT_BYTE, "Attachment" },
            { false, FT_BYTE, "DestinationAttachment" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "SoundEntriesID" },
            { true, FT_INT, "AnimKitID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellVisualMissileMeta::Instance(), HOTFIX_SEL_SPELL_VISUAL_MISSILE);
        return &loadInfo;
    }
};

struct SpellXDescriptionVariablesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "SpellDescriptionVariablesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellXDescriptionVariablesMeta::Instance(), HOTFIX_SEL_SPELL_X_DESCRIPTION_VARIABLES);
        return &loadInfo;
    }
};

struct SpellXSpellVisualLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "SpellVisualID" },
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Probability" },
            { false, FT_SHORT, "CasterPlayerConditionID" },
            { false, FT_SHORT, "CasterUnitConditionID" },
            { false, FT_SHORT, "ViewerPlayerConditionID" },
            { false, FT_SHORT, "ViewerUnitConditionID" },
            { true, FT_INT, "SpellIconFileID" },
            { true, FT_INT, "ActiveIconFileID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "DifficultyID" },
            { false, FT_BYTE, "Priority" },
            { false, FT_INT, "SpellID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SpellXSpellVisualMeta::Instance(), HOTFIX_SEL_SPELL_X_SPELL_VISUAL);
        return &loadInfo;
    }
};

struct StartupFilesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { true, FT_INT, "Locale" },
            { true, FT_INT, "BytesRequired" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, StartupFilesMeta::Instance(), HOTFIX_SEL_STARTUP_FILES);
        return &loadInfo;
    }
};

struct Startup_StringsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Message" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, Startup_StringsMeta::Instance(), HOTFIX_SEL_STARTUP__STRINGS);
        return &loadInfo;
    }
};

struct StationeryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ItemID" },
            { true, FT_INT, "TextureFileDataID1" },
            { true, FT_INT, "TextureFileDataID2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, StationeryMeta::Instance(), HOTFIX_SEL_STATIONERY);
        return &loadInfo;
    }
};

struct SummonPropertiesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Flags" },
            { true, FT_INT, "Control" },
            { true, FT_INT, "Faction" },
            { true, FT_INT, "Title" },
            { true, FT_INT, "Slot" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, SummonPropertiesMeta::Instance(), HOTFIX_SEL_SUMMON_PROPERTIES);
        return &loadInfo;
    }
};

struct TactKeyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Key1" },
            { false, FT_BYTE, "Key2" },
            { false, FT_BYTE, "Key3" },
            { false, FT_BYTE, "Key4" },
            { false, FT_BYTE, "Key5" },
            { false, FT_BYTE, "Key6" },
            { false, FT_BYTE, "Key7" },
            { false, FT_BYTE, "Key8" },
            { false, FT_BYTE, "Key9" },
            { false, FT_BYTE, "Key10" },
            { false, FT_BYTE, "Key11" },
            { false, FT_BYTE, "Key12" },
            { false, FT_BYTE, "Key13" },
            { false, FT_BYTE, "Key14" },
            { false, FT_BYTE, "Key15" },
            { false, FT_BYTE, "Key16" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TactKeyMeta::Instance(), HOTFIX_SEL_TACT_KEY);
        return &loadInfo;
    }
};

struct TactKeyLookupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "TACTID1" },
            { false, FT_BYTE, "TACTID2" },
            { false, FT_BYTE, "TACTID3" },
            { false, FT_BYTE, "TACTID4" },
            { false, FT_BYTE, "TACTID5" },
            { false, FT_BYTE, "TACTID6" },
            { false, FT_BYTE, "TACTID7" },
            { false, FT_BYTE, "TACTID8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TactKeyLookupMeta::Instance(), HOTFIX_SEL_TACT_KEY_LOOKUP);
        return &loadInfo;
    }
};

struct TalentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Description" },
            { true, FT_INT, "SpellID" },
            { true, FT_INT, "OverridesSpellID" },
            { false, FT_SHORT, "SpecID" },
            { false, FT_BYTE, "TierID" },
            { false, FT_BYTE, "ColumnIndex" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "CategoryMask1" },
            { false, FT_BYTE, "CategoryMask2" },
            { false, FT_BYTE, "ClassID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TalentMeta::Instance(), HOTFIX_SEL_TALENT);
        return &loadInfo;
    }
};

struct TaxiNodesLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "PosX" },
            { false, FT_FLOAT, "PosY" },
            { false, FT_FLOAT, "PosZ" },
            { true, FT_INT, "MountCreatureID1" },
            { true, FT_INT, "MountCreatureID2" },
            { false, FT_FLOAT, "MapOffset1" },
            { false, FT_FLOAT, "MapOffset2" },
            { false, FT_FLOAT, "Facing" },
            { false, FT_FLOAT, "FlightMapOffset1" },
            { false, FT_FLOAT, "FlightMapOffset2" },
            { false, FT_SHORT, "ContinentID" },
            { false, FT_SHORT, "ConditionID" },
            { false, FT_SHORT, "CharacterBitNumber" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "UiTextureKitID" },
            { true, FT_INT, "SpecialIconConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiNodesMeta::Instance(), HOTFIX_SEL_TAXI_NODES);
        return &loadInfo;
    }
};

struct TaxiPathLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_SHORT, "FromTaxiNode" },
            { false, FT_SHORT, "ToTaxiNode" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "Cost" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiPathMeta::Instance(), HOTFIX_SEL_TAXI_PATH);
        return &loadInfo;
    }
};

struct TaxiPathNodeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_FLOAT, "LocX" },
            { false, FT_FLOAT, "LocY" },
            { false, FT_FLOAT, "LocZ" },
            { false, FT_SHORT, "PathID" },
            { false, FT_SHORT, "ContinentID" },
            { false, FT_BYTE, "NodeIndex" },
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "Delay" },
            { false, FT_SHORT, "ArrivalEventID" },
            { false, FT_SHORT, "DepartureEventID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TaxiPathNodeMeta::Instance(), HOTFIX_SEL_TAXI_PATH_NODE);
        return &loadInfo;
    }
};

struct TerrainMaterialLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Shader" },
            { true, FT_INT, "EnvMapDiffuseFileID" },
            { true, FT_INT, "EnvMapSpecularFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TerrainMaterialMeta::Instance(), HOTFIX_SEL_TERRAIN_MATERIAL);
        return &loadInfo;
    }
};

struct TerrainTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "TerrainDesc" },
            { false, FT_SHORT, "FootstepSprayRun" },
            { false, FT_SHORT, "FootstepSprayWalk" },
            { false, FT_BYTE, "SoundID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TerrainTypeMeta::Instance(), HOTFIX_SEL_TERRAIN_TYPE);
        return &loadInfo;
    }
};

struct TerrainTypeSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TerrainTypeSoundsMeta::Instance(), HOTFIX_SEL_TERRAIN_TYPE_SOUNDS);
        return &loadInfo;
    }
};

struct TextureBlendSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "TextureFileDataID1" },
            { true, FT_INT, "TextureFileDataID2" },
            { true, FT_INT, "TextureFileDataID3" },
            { false, FT_FLOAT, "TextureScrollRateU1" },
            { false, FT_FLOAT, "TextureScrollRateU2" },
            { false, FT_FLOAT, "TextureScrollRateU3" },
            { false, FT_FLOAT, "TextureScrollRateV1" },
            { false, FT_FLOAT, "TextureScrollRateV2" },
            { false, FT_FLOAT, "TextureScrollRateV3" },
            { false, FT_FLOAT, "TextureScaleU1" },
            { false, FT_FLOAT, "TextureScaleU2" },
            { false, FT_FLOAT, "TextureScaleU3" },
            { false, FT_FLOAT, "TextureScaleV1" },
            { false, FT_FLOAT, "TextureScaleV2" },
            { false, FT_FLOAT, "TextureScaleV3" },
            { false, FT_FLOAT, "ModX1" },
            { false, FT_FLOAT, "ModX2" },
            { false, FT_FLOAT, "ModX3" },
            { false, FT_FLOAT, "ModX4" },
            { false, FT_BYTE, "SwizzleRed" },
            { false, FT_BYTE, "SwizzleGreen" },
            { false, FT_BYTE, "SwizzleBlue" },
            { false, FT_BYTE, "SwizzleAlpha" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TextureBlendSetMeta::Instance(), HOTFIX_SEL_TEXTURE_BLEND_SET);
        return &loadInfo;
    }
};

struct TextureFileDataLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "MaterialResourcesID" },
            { false, FT_BYTE, "UsageType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TextureFileDataMeta::Instance(), HOTFIX_SEL_TEXTURE_FILE_DATA);
        return &loadInfo;
    }
};

struct TotemCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_INT, "TotemCategoryMask" },
            { false, FT_BYTE, "TotemCategoryType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TotemCategoryMeta::Instance(), HOTFIX_SEL_TOTEM_CATEGORY);
        return &loadInfo;
    }
};

struct ToyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "SourceText" },
            { true, FT_INT, "ItemID" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "SourceTypeEnum" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ToyMeta::Instance(), HOTFIX_SEL_TOY);
        return &loadInfo;
    }
};

struct TradeSkillCategoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "HordeName" },
            { false, FT_SHORT, "SkillLineID" },
            { false, FT_SHORT, "ParentTradeSkillCategoryID" },
            { false, FT_SHORT, "OrderIndex" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TradeSkillCategoryMeta::Instance(), HOTFIX_SEL_TRADE_SKILL_CATEGORY);
        return &loadInfo;
    }
};

struct TradeSkillItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "ItemLevel" },
            { false, FT_BYTE, "RequiredLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TradeSkillItemMeta::Instance(), HOTFIX_SEL_TRADE_SKILL_ITEM);
        return &loadInfo;
    }
};

struct TransformMatrixLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_FLOAT, "Pos3" },
            { false, FT_FLOAT, "Yaw" },
            { false, FT_FLOAT, "Pitch" },
            { false, FT_FLOAT, "Roll" },
            { false, FT_FLOAT, "Scale" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransformMatrixMeta::Instance(), HOTFIX_SEL_TRANSFORM_MATRIX);
        return &loadInfo;
    }
};

struct TransmogHolidayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "RequiredTransmogHoliday" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransmogHolidayMeta::Instance(), HOTFIX_SEL_TRANSMOG_HOLIDAY);
        return &loadInfo;
    }
};

struct TransmogSetLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "ParentTransmogSetID" },
            { false, FT_SHORT, "UiOrder" },
            { false, FT_BYTE, "ExpansionID" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "TrackingQuestID" },
            { true, FT_INT, "ClassMask" },
            { true, FT_INT, "ItemNameDescriptionID" },
            { true, FT_INT, "TransmogSetGroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransmogSetMeta::Instance(), HOTFIX_SEL_TRANSMOG_SET);
        return &loadInfo;
    }
};

struct TransmogSetGroupLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Name" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransmogSetGroupMeta::Instance(), HOTFIX_SEL_TRANSMOG_SET_GROUP);
        return &loadInfo;
    }
};

struct TransmogSetItemLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "TransmogSetID" },
            { true, FT_INT, "ItemModifiedAppearanceID" },
            { true, FT_INT, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransmogSetItemMeta::Instance(), HOTFIX_SEL_TRANSMOG_SET_ITEM);
        return &loadInfo;
    }
};

struct TransportAnimationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "TimeIndex" },
            { false, FT_FLOAT, "PosX" },
            { false, FT_FLOAT, "PosY" },
            { false, FT_FLOAT, "PosZ" },
            { false, FT_BYTE, "SequenceID" },
            { false, FT_INT, "TransportID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportAnimationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ANIMATION);
        return &loadInfo;
    }
};

struct TransportPhysicsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "WaveAmp" },
            { false, FT_FLOAT, "WaveTimeScale" },
            { false, FT_FLOAT, "RollAmp" },
            { false, FT_FLOAT, "RollTimeScale" },
            { false, FT_FLOAT, "PitchAmp" },
            { false, FT_FLOAT, "PitchTimeScale" },
            { false, FT_FLOAT, "MaxBank" },
            { false, FT_FLOAT, "MaxBankTurnSpeed" },
            { false, FT_FLOAT, "SpeedDampThresh" },
            { false, FT_FLOAT, "SpeedDamp" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportPhysicsMeta::Instance(), HOTFIX_SEL_TRANSPORT_PHYSICS);
        return &loadInfo;
    }
};

struct TransportRotationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "TimeIndex" },
            { false, FT_FLOAT, "X" },
            { false, FT_FLOAT, "Y" },
            { false, FT_FLOAT, "Z" },
            { false, FT_FLOAT, "W" },
            { false, FT_INT, "TransportID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TransportRotationMeta::Instance(), HOTFIX_SEL_TRANSPORT_ROTATION);
        return &loadInfo;
    }
};

struct TrophyLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "GameObjectDisplayInfoID" },
            { false, FT_BYTE, "TrophyTypeID" },
            { true, FT_INT, "PlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, TrophyMeta::Instance(), HOTFIX_SEL_TROPHY);
        return &loadInfo;
    }
};

struct UiCameraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_FLOAT, "Pos3" },
            { false, FT_FLOAT, "LookAt1" },
            { false, FT_FLOAT, "LookAt2" },
            { false, FT_FLOAT, "LookAt3" },
            { false, FT_FLOAT, "Up1" },
            { false, FT_FLOAT, "Up2" },
            { false, FT_FLOAT, "Up3" },
            { false, FT_SHORT, "AnimFrame" },
            { false, FT_BYTE, "UiCameraTypeID" },
            { false, FT_BYTE, "AnimVariation" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "AnimID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiCameraMeta::Instance(), HOTFIX_SEL_UI_CAMERA);
        return &loadInfo;
    }
};

struct UiCameraTypeLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { true, FT_INT, "Width" },
            { true, FT_INT, "Height" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiCameraTypeMeta::Instance(), HOTFIX_SEL_UI_CAMERA_TYPE);
        return &loadInfo;
    }
};

struct UiCamFbackTransmogChrRaceLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "UiCameraID" },
            { false, FT_BYTE, "ChrRaceID" },
            { false, FT_BYTE, "Gender" },
            { false, FT_BYTE, "InventoryType" },
            { false, FT_BYTE, "Variation" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiCamFbackTransmogChrRaceMeta::Instance(), HOTFIX_SEL_UI_CAM_FBACK_TRANSMOG_CHR_RACE);
        return &loadInfo;
    }
};

struct UiCamFbackTransmogWeaponLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "UiCameraID" },
            { false, FT_BYTE, "ItemClass" },
            { false, FT_BYTE, "ItemSubclass" },
            { false, FT_BYTE, "InventoryType" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiCamFbackTransmogWeaponMeta::Instance(), HOTFIX_SEL_UI_CAM_FBACK_TRANSMOG_WEAPON);
        return &loadInfo;
    }
};

struct UIExpansionDisplayInfoLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "ExpansionLogo" },
            { true, FT_INT, "ExpansionBanner" },
            { true, FT_INT, "ExpansionLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UIExpansionDisplayInfoMeta::Instance(), HOTFIX_SEL_U_I_EXPANSION_DISPLAY_INFO);
        return &loadInfo;
    }
};

struct UIExpansionDisplayInfoIconLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "FeatureDescription" },
            { true, FT_INT, "ParentID" },
            { true, FT_INT, "FeatureIcon" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UIExpansionDisplayInfoIconMeta::Instance(), HOTFIX_SEL_U_I_EXPANSION_DISPLAY_INFO_ICON);
        return &loadInfo;
    }
};

struct UiMapPOILoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ContinentID" },
            { false, FT_FLOAT, "WorldLoc1" },
            { false, FT_FLOAT, "WorldLoc2" },
            { false, FT_FLOAT, "WorldLoc3" },
            { true, FT_INT, "UiTextureAtlasMemberID" },
            { true, FT_INT, "Flags" },
            { false, FT_SHORT, "PoiDataType" },
            { false, FT_SHORT, "PoiData" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiMapPOIMeta::Instance(), HOTFIX_SEL_UI_MAP_P_O_I);
        return &loadInfo;
    }
};

struct UiModelSceneLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "UiSystemType" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiModelSceneMeta::Instance(), HOTFIX_SEL_UI_MODEL_SCENE);
        return &loadInfo;
    }
};

struct UiModelSceneActorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "ScriptTag" },
            { false, FT_FLOAT, "Position1" },
            { false, FT_FLOAT, "Position2" },
            { false, FT_FLOAT, "Position3" },
            { false, FT_FLOAT, "OrientationYaw" },
            { false, FT_FLOAT, "OrientationPitch" },
            { false, FT_FLOAT, "OrientationRoll" },
            { false, FT_FLOAT, "NormalizedScale" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "UiModelSceneActorDisplayID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiModelSceneActorMeta::Instance(), HOTFIX_SEL_UI_MODEL_SCENE_ACTOR);
        return &loadInfo;
    }
};

struct UiModelSceneActorDisplayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "AnimSpeed" },
            { false, FT_FLOAT, "Alpha" },
            { false, FT_FLOAT, "Scale" },
            { true, FT_INT, "AnimationID" },
            { true, FT_INT, "SequenceVariation" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiModelSceneActorDisplayMeta::Instance(), HOTFIX_SEL_UI_MODEL_SCENE_ACTOR_DISPLAY);
        return &loadInfo;
    }
};

struct UiModelSceneCameraLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "ScriptTag" },
            { false, FT_FLOAT, "Target1" },
            { false, FT_FLOAT, "Target2" },
            { false, FT_FLOAT, "Target3" },
            { false, FT_FLOAT, "ZoomedTargetOffset1" },
            { false, FT_FLOAT, "ZoomedTargetOffset2" },
            { false, FT_FLOAT, "ZoomedTargetOffset3" },
            { false, FT_FLOAT, "Yaw" },
            { false, FT_FLOAT, "Pitch" },
            { false, FT_FLOAT, "Roll" },
            { false, FT_FLOAT, "ZoomedYawOffset" },
            { false, FT_FLOAT, "ZoomedPitchOffset" },
            { false, FT_FLOAT, "ZoomedRollOffset" },
            { false, FT_FLOAT, "ZoomDistance" },
            { false, FT_FLOAT, "MinZoomDistance" },
            { false, FT_FLOAT, "MaxZoomDistance" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "CameraType" },
            { true, FT_INT, "ID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiModelSceneCameraMeta::Instance(), HOTFIX_SEL_UI_MODEL_SCENE_CAMERA);
        return &loadInfo;
    }
};

struct UiTextureAtlasLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_SHORT, "AtlasHeight" },
            { false, FT_SHORT, "AtlasWidth" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiTextureAtlasMeta::Instance(), HOTFIX_SEL_UI_TEXTURE_ATLAS);
        return &loadInfo;
    }
};

struct UiTextureAtlasMemberLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "CommittedName" },
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "UiTextureAtlasID" },
            { false, FT_SHORT, "CommittedLeft" },
            { false, FT_SHORT, "CommittedRight" },
            { false, FT_SHORT, "CommittedTop" },
            { false, FT_SHORT, "CommittedBottom" },
            { false, FT_BYTE, "CommittedFlags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiTextureAtlasMemberMeta::Instance(), HOTFIX_SEL_UI_TEXTURE_ATLAS_MEMBER);
        return &loadInfo;
    }
};

struct UiTextureKitLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "KitPrefix" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UiTextureKitMeta::Instance(), HOTFIX_SEL_UI_TEXTURE_KIT);
        return &loadInfo;
    }
};

struct UnitBloodLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "PlayerCritBloodSpurtID" },
            { true, FT_INT, "PlayerHitBloodSpurtID" },
            { true, FT_INT, "DefaultBloodSpurtID" },
            { true, FT_INT, "PlayerOmniCritBloodSpurtID" },
            { true, FT_INT, "PlayerOmniHitBloodSpurtID" },
            { true, FT_INT, "DefaultOmniBloodSpurtID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UnitBloodMeta::Instance(), HOTFIX_SEL_UNIT_BLOOD);
        return &loadInfo;
    }
};

struct UnitBloodLevelsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "Violencelevel1" },
            { false, FT_BYTE, "Violencelevel2" },
            { false, FT_BYTE, "Violencelevel3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UnitBloodLevelsMeta::Instance(), HOTFIX_SEL_UNIT_BLOOD_LEVELS);
        return &loadInfo;
    }
};

struct UnitConditionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "Value1" },
            { true, FT_INT, "Value2" },
            { true, FT_INT, "Value3" },
            { true, FT_INT, "Value4" },
            { true, FT_INT, "Value5" },
            { true, FT_INT, "Value6" },
            { true, FT_INT, "Value7" },
            { true, FT_INT, "Value8" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "Variable1" },
            { false, FT_BYTE, "Variable2" },
            { false, FT_BYTE, "Variable3" },
            { false, FT_BYTE, "Variable4" },
            { false, FT_BYTE, "Variable5" },
            { false, FT_BYTE, "Variable6" },
            { false, FT_BYTE, "Variable7" },
            { false, FT_BYTE, "Variable8" },
            { false, FT_BYTE, "Op1" },
            { false, FT_BYTE, "Op2" },
            { false, FT_BYTE, "Op3" },
            { false, FT_BYTE, "Op4" },
            { false, FT_BYTE, "Op5" },
            { false, FT_BYTE, "Op6" },
            { false, FT_BYTE, "Op7" },
            { false, FT_BYTE, "Op8" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UnitConditionMeta::Instance(), HOTFIX_SEL_UNIT_CONDITION);
        return &loadInfo;
    }
};

struct UnitPowerBarLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_STRING, "Cost" },
            { false, FT_STRING, "OutOfError" },
            { false, FT_STRING, "ToolTip" },
            { false, FT_FLOAT, "RegenerationPeace" },
            { false, FT_FLOAT, "RegenerationCombat" },
            { true, FT_INT, "FileDataID1" },
            { true, FT_INT, "FileDataID2" },
            { true, FT_INT, "FileDataID3" },
            { true, FT_INT, "FileDataID4" },
            { true, FT_INT, "FileDataID5" },
            { true, FT_INT, "FileDataID6" },
            { false, FT_INT, "Color1" },
            { false, FT_INT, "Color2" },
            { false, FT_INT, "Color3" },
            { false, FT_INT, "Color4" },
            { false, FT_INT, "Color5" },
            { false, FT_INT, "Color6" },
            { false, FT_FLOAT, "StartInset" },
            { false, FT_FLOAT, "EndInset" },
            { false, FT_SHORT, "StartPower" },
            { false, FT_SHORT, "Flags" },
            { false, FT_BYTE, "CenterPower" },
            { false, FT_BYTE, "BarType" },
            { true, FT_INT, "MinPower" },
            { true, FT_INT, "MaxPower" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, UnitPowerBarMeta::Instance(), HOTFIX_SEL_UNIT_POWER_BAR);
        return &loadInfo;
    }
};

struct VehicleLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Flags" },
            { false, FT_FLOAT, "TurnSpeed" },
            { false, FT_FLOAT, "PitchSpeed" },
            { false, FT_FLOAT, "PitchMin" },
            { false, FT_FLOAT, "PitchMax" },
            { false, FT_FLOAT, "MouseLookOffsetPitch" },
            { false, FT_FLOAT, "CameraFadeDistScalarMin" },
            { false, FT_FLOAT, "CameraFadeDistScalarMax" },
            { false, FT_FLOAT, "CameraPitchOffset" },
            { false, FT_FLOAT, "FacingLimitRight" },
            { false, FT_FLOAT, "FacingLimitLeft" },
            { false, FT_FLOAT, "CameraYawOffset" },
            { false, FT_SHORT, "SeatID1" },
            { false, FT_SHORT, "SeatID2" },
            { false, FT_SHORT, "SeatID3" },
            { false, FT_SHORT, "SeatID4" },
            { false, FT_SHORT, "SeatID5" },
            { false, FT_SHORT, "SeatID6" },
            { false, FT_SHORT, "SeatID7" },
            { false, FT_SHORT, "SeatID8" },
            { false, FT_SHORT, "VehicleUIIndicatorID" },
            { false, FT_SHORT, "PowerDisplayID1" },
            { false, FT_SHORT, "PowerDisplayID2" },
            { false, FT_SHORT, "PowerDisplayID3" },
            { false, FT_BYTE, "FlagsB" },
            { false, FT_BYTE, "UiLocomotionType" },
            { true, FT_INT, "MissileTargetingID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleMeta::Instance(), HOTFIX_SEL_VEHICLE);
        return &loadInfo;
    }
};

struct VehicleSeatLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "Flags" },
            { false, FT_INT, "FlagsB" },
            { false, FT_INT, "FlagsC" },
            { false, FT_FLOAT, "AttachmentOffsetX" },
            { false, FT_FLOAT, "AttachmentOffsetY" },
            { false, FT_FLOAT, "AttachmentOffsetZ" },
            { false, FT_FLOAT, "EnterPreDelay" },
            { false, FT_FLOAT, "EnterSpeed" },
            { false, FT_FLOAT, "EnterGravity" },
            { false, FT_FLOAT, "EnterMinDuration" },
            { false, FT_FLOAT, "EnterMaxDuration" },
            { false, FT_FLOAT, "EnterMinArcHeight" },
            { false, FT_FLOAT, "EnterMaxArcHeight" },
            { false, FT_FLOAT, "ExitPreDelay" },
            { false, FT_FLOAT, "ExitSpeed" },
            { false, FT_FLOAT, "ExitGravity" },
            { false, FT_FLOAT, "ExitMinDuration" },
            { false, FT_FLOAT, "ExitMaxDuration" },
            { false, FT_FLOAT, "ExitMinArcHeight" },
            { false, FT_FLOAT, "ExitMaxArcHeight" },
            { false, FT_FLOAT, "PassengerYaw" },
            { false, FT_FLOAT, "PassengerPitch" },
            { false, FT_FLOAT, "PassengerRoll" },
            { false, FT_FLOAT, "VehicleEnterAnimDelay" },
            { false, FT_FLOAT, "VehicleExitAnimDelay" },
            { false, FT_FLOAT, "CameraEnteringDelay" },
            { false, FT_FLOAT, "CameraEnteringDuration" },
            { false, FT_FLOAT, "CameraExitingDelay" },
            { false, FT_FLOAT, "CameraExitingDuration" },
            { false, FT_FLOAT, "CameraOffsetX" },
            { false, FT_FLOAT, "CameraOffsetY" },
            { false, FT_FLOAT, "CameraOffsetZ" },
            { false, FT_FLOAT, "CameraPosChaseRate" },
            { false, FT_FLOAT, "CameraFacingChaseRate" },
            { false, FT_FLOAT, "CameraEnteringZoom" },
            { false, FT_FLOAT, "CameraSeatZoomMin" },
            { false, FT_FLOAT, "CameraSeatZoomMax" },
            { true, FT_INT, "UiSkinFileDataID" },
            { false, FT_SHORT, "EnterAnimStart" },
            { false, FT_SHORT, "EnterAnimLoop" },
            { false, FT_SHORT, "RideAnimStart" },
            { false, FT_SHORT, "RideAnimLoop" },
            { false, FT_SHORT, "RideUpperAnimStart" },
            { false, FT_SHORT, "RideUpperAnimLoop" },
            { false, FT_SHORT, "ExitAnimStart" },
            { false, FT_SHORT, "ExitAnimLoop" },
            { false, FT_SHORT, "ExitAnimEnd" },
            { false, FT_SHORT, "VehicleEnterAnim" },
            { false, FT_SHORT, "VehicleExitAnim" },
            { false, FT_SHORT, "VehicleRideAnimLoop" },
            { false, FT_SHORT, "EnterAnimKitID" },
            { false, FT_SHORT, "RideAnimKitID" },
            { false, FT_SHORT, "ExitAnimKitID" },
            { false, FT_SHORT, "VehicleEnterAnimKitID" },
            { false, FT_SHORT, "VehicleRideAnimKitID" },
            { false, FT_SHORT, "VehicleExitAnimKitID" },
            { false, FT_SHORT, "CameraModeID" },
            { false, FT_BYTE, "AttachmentID" },
            { false, FT_BYTE, "PassengerAttachmentID" },
            { false, FT_BYTE, "VehicleEnterAnimBone" },
            { false, FT_BYTE, "VehicleExitAnimBone" },
            { false, FT_BYTE, "VehicleRideAnimLoopBone" },
            { false, FT_BYTE, "VehicleAbilityDisplay" },
            { true, FT_INT, "EnterUISoundID" },
            { true, FT_INT, "ExitUISoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleSeatMeta::Instance(), HOTFIX_SEL_VEHICLE_SEAT);
        return &loadInfo;
    }
};

struct VehicleUIIndicatorLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "BackgroundTextureFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleUIIndicatorMeta::Instance(), HOTFIX_SEL_VEHICLE_U_I_INDICATOR);
        return &loadInfo;
    }
};

struct VehicleUIIndSeatLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "XPos" },
            { false, FT_FLOAT, "YPos" },
            { false, FT_BYTE, "VirtualSeatIndex" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VehicleUIIndSeatMeta::Instance(), HOTFIX_SEL_VEHICLE_U_I_IND_SEAT);
        return &loadInfo;
    }
};

struct VignetteLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "MaxHeight" },
            { false, FT_FLOAT, "MinHeight" },
            { true, FT_INT, "QuestFeedbackEffectID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "VisibleTrackingQuestID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VignetteMeta::Instance(), HOTFIX_SEL_VIGNETTE);
        return &loadInfo;
    }
};

struct VirtualAttachmentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "PositionerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VirtualAttachmentMeta::Instance(), HOTFIX_SEL_VIRTUAL_ATTACHMENT);
        return &loadInfo;
    }
};

struct VirtualAttachmentCustomizationLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_SHORT, "VirtualAttachmentID" },
            { false, FT_SHORT, "PositionerID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VirtualAttachmentCustomizationMeta::Instance(), HOTFIX_SEL_VIRTUAL_ATTACHMENT_CUSTOMIZATION);
        return &loadInfo;
    }
};

struct VocalUISoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "VocalUIEnum" },
            { false, FT_BYTE, "RaceID" },
            { false, FT_BYTE, "ClassID" },
            { true, FT_INT, "NormalSoundID1" },
            { true, FT_INT, "NormalSoundID2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, VocalUISoundsMeta::Instance(), HOTFIX_SEL_VOCAL_U_I_SOUNDS);
        return &loadInfo;
    }
};

struct WbAccessControlListLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "URL" },
            { false, FT_SHORT, "GrantFlags" },
            { false, FT_BYTE, "RevokeFlags" },
            { false, FT_BYTE, "WowEditInternal" },
            { false, FT_BYTE, "RegionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WbAccessControlListMeta::Instance(), HOTFIX_SEL_WB_ACCESS_CONTROL_LIST);
        return &loadInfo;
    }
};

struct WbCertWhitelistLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Domain" },
            { false, FT_BYTE, "GrantAccess" },
            { false, FT_BYTE, "RevokeAccess" },
            { false, FT_BYTE, "WowEditInternal" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WbCertWhitelistMeta::Instance(), HOTFIX_SEL_WB_CERT_WHITELIST);
        return &loadInfo;
    }
};

struct WeaponImpactSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "WeaponSubClassID" },
            { false, FT_BYTE, "ParrySoundType" },
            { false, FT_BYTE, "ImpactSource" },
            { true, FT_INT, "ImpactSoundID1" },
            { true, FT_INT, "ImpactSoundID2" },
            { true, FT_INT, "ImpactSoundID3" },
            { true, FT_INT, "ImpactSoundID4" },
            { true, FT_INT, "ImpactSoundID5" },
            { true, FT_INT, "ImpactSoundID6" },
            { true, FT_INT, "ImpactSoundID7" },
            { true, FT_INT, "ImpactSoundID8" },
            { true, FT_INT, "ImpactSoundID9" },
            { true, FT_INT, "ImpactSoundID10" },
            { true, FT_INT, "ImpactSoundID11" },
            { true, FT_INT, "CritImpactSoundID1" },
            { true, FT_INT, "CritImpactSoundID2" },
            { true, FT_INT, "CritImpactSoundID3" },
            { true, FT_INT, "CritImpactSoundID4" },
            { true, FT_INT, "CritImpactSoundID5" },
            { true, FT_INT, "CritImpactSoundID6" },
            { true, FT_INT, "CritImpactSoundID7" },
            { true, FT_INT, "CritImpactSoundID8" },
            { true, FT_INT, "CritImpactSoundID9" },
            { true, FT_INT, "CritImpactSoundID10" },
            { true, FT_INT, "CritImpactSoundID11" },
            { true, FT_INT, "PierceImpactSoundID1" },
            { true, FT_INT, "PierceImpactSoundID2" },
            { true, FT_INT, "PierceImpactSoundID3" },
            { true, FT_INT, "PierceImpactSoundID4" },
            { true, FT_INT, "PierceImpactSoundID5" },
            { true, FT_INT, "PierceImpactSoundID6" },
            { true, FT_INT, "PierceImpactSoundID7" },
            { true, FT_INT, "PierceImpactSoundID8" },
            { true, FT_INT, "PierceImpactSoundID9" },
            { true, FT_INT, "PierceImpactSoundID10" },
            { true, FT_INT, "PierceImpactSoundID11" },
            { true, FT_INT, "PierceCritImpactSoundID1" },
            { true, FT_INT, "PierceCritImpactSoundID2" },
            { true, FT_INT, "PierceCritImpactSoundID3" },
            { true, FT_INT, "PierceCritImpactSoundID4" },
            { true, FT_INT, "PierceCritImpactSoundID5" },
            { true, FT_INT, "PierceCritImpactSoundID6" },
            { true, FT_INT, "PierceCritImpactSoundID7" },
            { true, FT_INT, "PierceCritImpactSoundID8" },
            { true, FT_INT, "PierceCritImpactSoundID9" },
            { true, FT_INT, "PierceCritImpactSoundID10" },
            { true, FT_INT, "PierceCritImpactSoundID11" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WeaponImpactSoundsMeta::Instance(), HOTFIX_SEL_WEAPON_IMPACT_SOUNDS);
        return &loadInfo;
    }
};

struct WeaponSwingSounds2LoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_BYTE, "SwingType" },
            { false, FT_BYTE, "Crit" },
            { true, FT_INT, "SoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WeaponSwingSounds2Meta::Instance(), HOTFIX_SEL_WEAPON_SWING_SOUNDS2);
        return &loadInfo;
    }
};

struct WeaponTrailLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_FLOAT, "Yaw" },
            { false, FT_FLOAT, "Pitch" },
            { false, FT_FLOAT, "Roll" },
            { true, FT_INT, "TextureFileDataID1" },
            { true, FT_INT, "TextureFileDataID2" },
            { true, FT_INT, "TextureFileDataID3" },
            { false, FT_FLOAT, "TextureScrollRateU1" },
            { false, FT_FLOAT, "TextureScrollRateU2" },
            { false, FT_FLOAT, "TextureScrollRateU3" },
            { false, FT_FLOAT, "TextureScrollRateV1" },
            { false, FT_FLOAT, "TextureScrollRateV2" },
            { false, FT_FLOAT, "TextureScrollRateV3" },
            { false, FT_FLOAT, "TextureScaleU1" },
            { false, FT_FLOAT, "TextureScaleU2" },
            { false, FT_FLOAT, "TextureScaleU3" },
            { false, FT_FLOAT, "TextureScaleV1" },
            { false, FT_FLOAT, "TextureScaleV2" },
            { false, FT_FLOAT, "TextureScaleV3" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WeaponTrailMeta::Instance(), HOTFIX_SEL_WEAPON_TRAIL);
        return &loadInfo;
    }
};

struct WeaponTrailModelDefLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "LowDefFileDataID" },
            { false, FT_SHORT, "WeaponTrailID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WeaponTrailModelDefMeta::Instance(), HOTFIX_SEL_WEAPON_TRAIL_MODEL_DEF);
        return &loadInfo;
    }
};

struct WeaponTrailParamLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_FLOAT, "FadeOutTime" },
            { false, FT_FLOAT, "EdgeLifeSpan" },
            { false, FT_FLOAT, "InitialDelay" },
            { false, FT_FLOAT, "SmoothSampleAngle" },
            { false, FT_BYTE, "Hand" },
            { false, FT_BYTE, "OverrideAttachTop" },
            { false, FT_BYTE, "OverrideAttachBot" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WeaponTrailParamMeta::Instance(), HOTFIX_SEL_WEAPON_TRAIL_PARAM);
        return &loadInfo;
    }
};

struct WeatherLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Intensity1" },
            { false, FT_FLOAT, "Intensity2" },
            { false, FT_FLOAT, "TransitionSkyBox" },
            { false, FT_FLOAT, "EffectColor1" },
            { false, FT_FLOAT, "EffectColor2" },
            { false, FT_FLOAT, "EffectColor3" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_FLOAT, "Volatility" },
            { false, FT_FLOAT, "TwinkleIntensity" },
            { false, FT_FLOAT, "FallModifier" },
            { false, FT_FLOAT, "RotationalSpeed" },
            { true, FT_INT, "ParticulateFileDataID" },
            { false, FT_SHORT, "SoundAmbienceID" },
            { false, FT_BYTE, "Type" },
            { false, FT_BYTE, "EffectType" },
            { false, FT_BYTE, "WindSettingsID" },
            { true, FT_INT, "AmbienceID" },
            { true, FT_INT, "EffectTextureFileDataID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WeatherMeta::Instance(), HOTFIX_SEL_WEATHER);
        return &loadInfo;
    }
};

struct WindSettingsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "BaseMag" },
            { false, FT_FLOAT, "BaseDir1" },
            { false, FT_FLOAT, "BaseDir2" },
            { false, FT_FLOAT, "BaseDir3" },
            { false, FT_FLOAT, "VarianceMagOver" },
            { false, FT_FLOAT, "VarianceMagUnder" },
            { false, FT_FLOAT, "VarianceDir1" },
            { false, FT_FLOAT, "VarianceDir2" },
            { false, FT_FLOAT, "VarianceDir3" },
            { false, FT_FLOAT, "MaxStepMag" },
            { false, FT_FLOAT, "MaxStepDir1" },
            { false, FT_FLOAT, "MaxStepDir2" },
            { false, FT_FLOAT, "MaxStepDir3" },
            { false, FT_FLOAT, "Frequency" },
            { false, FT_FLOAT, "Duration" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WindSettingsMeta::Instance(), HOTFIX_SEL_WIND_SETTINGS);
        return &loadInfo;
    }
};

struct WmoAreaTableLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "AreaName" },
            { true, FT_INT, "WmoGroupID" },
            { false, FT_SHORT, "AmbienceID" },
            { false, FT_SHORT, "ZoneMusic" },
            { false, FT_SHORT, "IntroSound" },
            { false, FT_SHORT, "AreaTableID" },
            { false, FT_SHORT, "UwIntroSound" },
            { false, FT_SHORT, "UwAmbience" },
            { false, FT_BYTE, "NameSetID" },
            { false, FT_BYTE, "SoundProviderPref" },
            { false, FT_BYTE, "SoundProviderPrefUnderwater" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "UwZoneMusic" },
            { false, FT_SHORT, "WmoID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WMOAreaTableMeta::Instance(), HOTFIX_SEL_WMO_AREA_TABLE);
        return &loadInfo;
    }
};

struct WmoMinimapTextureLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "FileDataID" },
            { false, FT_SHORT, "GroupNum" },
            { false, FT_BYTE, "BlockX" },
            { false, FT_BYTE, "BlockY" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WMOMinimapTextureMeta::Instance(), HOTFIX_SEL_WMO_MINIMAP_TEXTURE);
        return &loadInfo;
    }
};

struct WorldBossLockoutLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "TrackingQuestID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldBossLockoutMeta::Instance(), HOTFIX_SEL_WORLD_BOSS_LOCKOUT);
        return &loadInfo;
    }
};

struct WorldChunkSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "MapID" },
            { false, FT_BYTE, "ChunkX" },
            { false, FT_BYTE, "ChunkY" },
            { false, FT_BYTE, "SubChunkX" },
            { false, FT_BYTE, "SubChunkY" },
            { false, FT_BYTE, "SoundOverrideID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldChunkSoundsMeta::Instance(), HOTFIX_SEL_WORLD_CHUNK_SOUNDS);
        return &loadInfo;
    }
};

struct WorldEffectLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_INT, "TargetAsset" },
            { false, FT_SHORT, "CombatConditionID" },
            { false, FT_BYTE, "TargetType" },
            { false, FT_BYTE, "WhenToDisplay" },
            { true, FT_INT, "QuestFeedbackEffectID" },
            { true, FT_INT, "PlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldEffectMeta::Instance(), HOTFIX_SEL_WORLD_EFFECT);
        return &loadInfo;
    }
};

struct WorldElapsedTimerLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_BYTE, "Flags" },
            { false, FT_BYTE, "Type" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldElapsedTimerMeta::Instance(), HOTFIX_SEL_WORLD_ELAPSED_TIMER);
        return &loadInfo;
    }
};

struct WorldMapAreaLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "AreaName" },
            { false, FT_FLOAT, "LocLeft" },
            { false, FT_FLOAT, "LocRight" },
            { false, FT_FLOAT, "LocTop" },
            { false, FT_FLOAT, "LocBottom" },
            { true, FT_INT, "Flags" },
            { true, FT_SHORT, "MapID" },
            { false, FT_SHORT, "AreaID" },
            { true, FT_SHORT, "DisplayMapID" },
            { true, FT_SHORT, "DefaultDungeonFloor" },
            { true, FT_SHORT, "ParentWorldMapID" },
            { false, FT_BYTE, "LevelRangeMin" },
            { false, FT_BYTE, "LevelRangeMax" },
            { false, FT_BYTE, "BountySetID" },
            { false, FT_BYTE, "BountyDisplayLocation" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "VisibilityPlayerConditionID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapAreaMeta::Instance(), HOTFIX_SEL_WORLD_MAP_AREA);
        return &loadInfo;
    }
};

struct WorldMapContinentLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "ContinentOffset1" },
            { false, FT_FLOAT, "ContinentOffset2" },
            { false, FT_FLOAT, "Scale" },
            { false, FT_FLOAT, "TaxiMin1" },
            { false, FT_FLOAT, "TaxiMin2" },
            { false, FT_FLOAT, "TaxiMax1" },
            { false, FT_FLOAT, "TaxiMax2" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "WorldMapID" },
            { false, FT_BYTE, "LeftBoundary" },
            { false, FT_BYTE, "RightBoundary" },
            { false, FT_BYTE, "TopBoundary" },
            { false, FT_BYTE, "BottomBoundary" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapContinentMeta::Instance(), HOTFIX_SEL_WORLD_MAP_CONTINENT);
        return &loadInfo;
    }
};

struct WorldMapOverlayLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "TextureName" },
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "TextureWidth" },
            { false, FT_SHORT, "TextureHeight" },
            { true, FT_INT, "MapAreaID" },
            { true, FT_INT, "OffsetX" },
            { true, FT_INT, "OffsetY" },
            { true, FT_INT, "HitRectTop" },
            { true, FT_INT, "HitRectLeft" },
            { true, FT_INT, "HitRectBottom" },
            { true, FT_INT, "HitRectRight" },
            { true, FT_INT, "PlayerConditionID" },
            { true, FT_INT, "Flags" },
            { true, FT_INT, "AreaID1" },
            { true, FT_INT, "AreaID2" },
            { true, FT_INT, "AreaID3" },
            { true, FT_INT, "AreaID4" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapOverlayMeta::Instance(), HOTFIX_SEL_WORLD_MAP_OVERLAY);
        return &loadInfo;
    }
};

struct WorldMapTransformsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "RegionMinX" },
            { false, FT_FLOAT, "RegionMinY" },
            { false, FT_FLOAT, "RegionMinZ" },
            { false, FT_FLOAT, "RegionMaxX" },
            { false, FT_FLOAT, "RegionMaxY" },
            { false, FT_FLOAT, "RegionMaxZ" },
            { false, FT_FLOAT, "RegionOffsetX" },
            { false, FT_FLOAT, "RegionOffsetY" },
            { false, FT_FLOAT, "RegionScale" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "NewMapID" },
            { false, FT_SHORT, "NewDungeonMapID" },
            { false, FT_SHORT, "NewAreaID" },
            { false, FT_BYTE, "Flags" },
            { true, FT_INT, "Priority" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldMapTransformsMeta::Instance(), HOTFIX_SEL_WORLD_MAP_TRANSFORMS);
        return &loadInfo;
    }
};

struct WorldSafeLocsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_FLOAT, "LocX" },
            { false, FT_FLOAT, "LocY" },
            { false, FT_FLOAT, "LocZ" },
            { false, FT_FLOAT, "LocO" },
            { false, FT_SHORT, "MapID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldSafeLocsMeta::Instance(), HOTFIX_SEL_WORLD_SAFE_LOCS);
        return &loadInfo;
    }
};

struct WorldStateExpressionLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING_NOT_LOCALIZED, "Expression" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldStateExpressionMeta::Instance(), HOTFIX_SEL_WORLD_STATE_EXPRESSION);
        return &loadInfo;
    }
};

struct WorldStateUILoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { false, FT_STRING, "Icon" },
            { false, FT_STRING, "ExtendedUI" },
            { false, FT_STRING, "DynamicTooltip" },
            { false, FT_STRING, "String" },
            { false, FT_STRING, "Tooltip" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "PhaseID" },
            { false, FT_SHORT, "PhaseGroupID" },
            { false, FT_SHORT, "StateVariable" },
            { false, FT_SHORT, "ExtendedUIStateVariable1" },
            { false, FT_SHORT, "ExtendedUIStateVariable2" },
            { false, FT_SHORT, "ExtendedUIStateVariable3" },
            { false, FT_BYTE, "OrderIndex" },
            { false, FT_BYTE, "PhaseUseFlags" },
            { false, FT_BYTE, "Type" },
            { true, FT_INT, "ID" },
            { true, FT_INT, "DynamicIconFileID" },
            { true, FT_INT, "DynamicFlashIconFileID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldStateUIMeta::Instance(), HOTFIX_SEL_WORLD_STATE_U_I);
        return &loadInfo;
    }
};

struct WorldStateZoneSoundsLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "WmoAreaID" },
            { false, FT_SHORT, "WorldStateID" },
            { false, FT_SHORT, "WorldStateValue" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "ZoneIntroMusicID" },
            { false, FT_SHORT, "ZoneMusicID" },
            { false, FT_SHORT, "SoundAmbienceID" },
            { false, FT_BYTE, "SoundProviderPreferencesID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, WorldStateZoneSoundsMeta::Instance(), HOTFIX_SEL_WORLD_STATE_ZONE_SOUNDS);
        return &loadInfo;
    }
};

struct World_Pvp_AreaLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_SHORT, "AreaID" },
            { false, FT_SHORT, "NextTimeWorldstate" },
            { false, FT_SHORT, "GameTimeWorldstate" },
            { false, FT_SHORT, "BattlePopulate_time" },
            { false, FT_SHORT, "MapID" },
            { false, FT_BYTE, "MinLevel" },
            { false, FT_BYTE, "MaxLevel" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, World_PVP_AreaMeta::Instance(), HOTFIX_SEL_WORLD__PVP__AREA);
        return &loadInfo;
    }
};

struct ZoneIntroMusicTableLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "MinDelayMinutes" },
            { false, FT_BYTE, "Priority" },
            { true, FT_INT, "SoundID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ZoneIntroMusicTableMeta::Instance(), HOTFIX_SEL_ZONE_INTRO_MUSIC_TABLE);
        return &loadInfo;
    }
};

struct ZoneLightLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "Name" },
            { false, FT_SHORT, "MapID" },
            { false, FT_SHORT, "LightID" },
            { false, FT_BYTE, "Flags" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ZoneLightMeta::Instance(), HOTFIX_SEL_ZONE_LIGHT);
        return &loadInfo;
    }
};

struct ZoneLightPointLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_FLOAT, "Pos1" },
            { false, FT_FLOAT, "Pos2" },
            { false, FT_BYTE, "PointOrder" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ZoneLightPointMeta::Instance(), HOTFIX_SEL_ZONE_LIGHT_POINT);
        return &loadInfo;
    }
};

struct ZoneMusicLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { false, FT_STRING, "SetName" },
            { true, FT_INT, "SilenceIntervalMin1" },
            { true, FT_INT, "SilenceIntervalMin2" },
            { true, FT_INT, "SilenceIntervalMax1" },
            { true, FT_INT, "SilenceIntervalMax2" },
            { true, FT_INT, "Sounds1" },
            { true, FT_INT, "Sounds2" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ZoneMusicMeta::Instance(), HOTFIX_SEL_ZONE_MUSIC);
        return &loadInfo;
    }
};

struct ZoneStoryLoadInfo
{
    static DB2LoadInfo const* Instance()
    {
        static DB2FieldMeta const fields[] =
        {
            { true, FT_INT, "ID" },
            { true, FT_INT, "DisplayAchievementID" },
            { true, FT_INT, "DisplayWorldMapAreaID" },
            { false, FT_BYTE, "PlayerFactionGroupID" },
        };
        static DB2LoadInfo const loadInfo(&fields[0], std::extent<decltype(fields)>::value, ZoneStoryMeta::Instance(), HOTFIX_SEL_ZONE_STORY);
        return &loadInfo;
    }
};

#endif // DB2LoadInfo_h__
