EbenezerModel.h

#ifndef EBENEZER_MODEL_EBENEZERMODEL_H
#define EBENEZER_MODEL_EBENEZERMODEL_H
 
#pragma once
 
#include <ModelUtil/ModelUtil.h>
#include <cstdint>
#include <optional>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
 
namespace ebenezer_binder
{
    class Battle;
    class Coefficient;
    class CouponSerialList;
    class Event;
    class EventTrigger;
    class Home;
    class Item;
    class ItemExchange;
    class ItemUpgrade;
    class Knights;
    class KnightsAlliance;
    class KnightsCape;
    class KnightsRating;
    class KnightsSiegeWarfare;
    class KnightsUser;
    class LevelUp;
    class Magic;
    class MagicType1;
    class MagicType2;
    class MagicType3;
    class MagicType4;
    class MagicType5;
    class MagicType6;
    class MagicType7;
    class MagicType8;
    class MagicType9;
    class MonsterChallenge;
    class MonsterChallengeSummonList;
    class RentalItem;
    class ServerResource;
    class StartPosition;
    class UserKnightsRank;
    class UserPersonalRank;
    class WebpageAddress;
    class ZoneInfo;
}
 
namespace ebenezer_model
{
    class Battle 
    {
    public:
        using BinderType = ebenezer_binder::Battle;

        int16_t Index = {};

        uint8_t Nation = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class Coefficient 
    {
    public:
        using BinderType = ebenezer_binder::Coefficient;

        int16_t ClassId = {};

        double ShortSword = {};

        double Sword = {};

        double Axe = {};

        double Club = {};

        double Spear = {};

        double Pole = {};

        double Staff = {};

        double Bow = {};

        double HitPoint = {};

        double ManaPoint = {};

        double Sp = {};

        double Armor = {};

        double HitRate = {};

        double Evasionrate = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class CouponSerialList 
    {
    public:
        using BinderType = ebenezer_binder::CouponSerialList;

        int32_t Index = {};

        std::string SerialNum;

        int32_t ItemNumber = {};

        int16_t ItemCount = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class Event 
    {
    public:
        using BinderType = ebenezer_binder::Event;

        uint8_t ZoneNumber = {};

        int16_t EventNumber = {};

        uint8_t EventType = {};

        std::string Execute1;

        std::string Execute2;

        std::string Execute3;

        std::string Execute4;

        std::string Execute5;

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();
 
    };

    class EventTrigger 
    {
    public:
        using BinderType = ebenezer_binder::EventTrigger;

        int32_t Index = {};

        uint8_t NpcType = {};

        int16_t NpcId = {};

        int32_t TriggerNumber = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class Home 
    {
    public:
        using BinderType = ebenezer_binder::Home;

        uint8_t Nation = {};

        int32_t ElmoZoneX = {};

        int32_t ElmoZoneZ = {};

        uint8_t ElmoZoneLX = {};

        uint8_t ElmoZoneLZ = {};

        int32_t KarusZoneX = {};

        int32_t KarusZoneZ = {};

        uint8_t KarusZoneLX = {};

        uint8_t KarusZoneLZ = {};

        int32_t FreeZoneX = {};

        int32_t FreeZoneZ = {};

        uint8_t FreeZoneLX = {};

        uint8_t FreeZoneLZ = {};

        int32_t BattleZoneX = {};

        int32_t BattleZoneZ = {};

        uint8_t BattleZoneLX = {};

        uint8_t BattleZoneLZ = {};

        int32_t BattleZone2X = {};

        int32_t BattleZone2Z = {};

        uint8_t BattleZone2LX = {};

        uint8_t BattleZone2LZ = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const uint8_t& MapKey() const;
 
    };

    class Item 
    {
    public:
        using BinderType = ebenezer_binder::Item;

        int32_t ID = {};

        std::string Name;

        uint8_t Kind = {};

        enum class EnumKind
        {
            Dagger = 1,
            Sword = 2,
            Axe = 3,
            Mace = 4,
            Spear = 5,
            Shield = 6,
            Bow = 7,
            Longbow = 8,
            Launcher = 10,
            Staff = 11,
            Arrow = 12,
            Javelin = 13,
            ArmorWarrior = 21,
            ArmorRogue = 22,
            ArmorWizard = 23,
            ArmorPriest = 24
        };

        uint8_t Slot = {};

        enum class EnumSlot
        {
            RightEar = 0,
            Head = 1,
            LeftEar = 2,
            Neck = 3,
            Breast = 4,
            Shoulder = 5,
            RightHand = 6,
            Waist = 7,
            LeftHand = 8,
            RightRing = 9,
            Leg = 10,
            LeftRing = 11,
            Glove = 12,
            Foot = 13,
            Reserved = 14
        };

        uint8_t Race = {};

        enum class EnumRace
        {
            Any = 0,
            Karus = 1,
            ElMorad = 2
        };

        uint8_t ClassId = {};

        enum class EnumClassId
        {
            Any = 0,
            GroupWarrior = 1,
            GroupRogue = 2,
            GroupMage = 3,
            GroupCleric = 4,
            GroupWarriorJob = 5,
            GroupWarriorMaster = 6,
            GroupRogueJob = 7,
            GroupRogueMaster = 8,
            GroupMageJob = 9,
            GroupMageMaster = 10,
            GroupPriestJob = 11,
            GroupPriestMaster = 12,
            KarusWarrior = 101,
            KarusRogue = 102,
            KarusWizard = 103,
            KarusPriest = 104,
            Berserker = 105,
            Guardian = 106,
            Hunter = 107,
            Penetrator = 108,
            Sorcerer = 109,
            Necromancer = 110,
            Shaman = 111,
            DarkPriest = 112,
            ElmoWarrior = 201,
            ElmoRogue = 202,
            ElmoWizard = 203,
            ElmoPriest = 204,
            Blade = 205,
            Protector = 206,
            Ranger = 207,
            Assassin = 208,
            Mage = 209,
            Enchanter = 210,
            Cleric = 211,
            Druid = 212
        };

        int16_t Damage = {};

        int16_t Delay = {};

        int16_t Range = {};

        int16_t Weight = {};

        int16_t Durability = {};

        int32_t BuyPrice = {};

        int32_t SellPrice = {};

        int16_t Armor = {};

        uint8_t Countable = {};

        enum class EnumCountable
        {
            NonStackable = 0,
            Stackable = 1,
            Coins = 2
        };

        int32_t MagicEffect = {};

        int32_t SpecialEffect = {};

        enum class EnumSpecialEffect
        {
            ScrollTransform = 1,
            ScrollTransform2 = 2,
            ScrollTransform3 = 3,
            ScrollTransform4 = 4,
            ScrollAccessory = 253,
            ScrollRental = 254,
            ScrollUpgrade = 255,
            UniqueAxe = 12050000,
            UniqueSpear = 12070000,
            UniqueBow = 12120000,
            UniqueMace = 12130000,
            UniqueStaff = 40000000
        };

        uint8_t MinLevel = {};

        uint8_t RequiredRank = {};

        uint8_t RequiredTitle = {};

        enum class EnumRequiredTitle
        {
            Any = 0,
            King = 1,
            Chief = 1,
            ViceChief = 2,
            Knight = 3,
            Officer = 4,
            Trainee = 5,
            WarCommander = 100
        };

        uint8_t RequiredStrength = {};

        uint8_t RequiredStamina = {};

        uint8_t RequiredDexterity = {};

        uint8_t RequiredIntelligence = {};

        uint8_t RequiredCharisma = {};

        uint8_t SellingGroup = {};

        uint8_t Type = {};

        int16_t HitRate = {};

        int16_t EvasionRate = {};

        int16_t DaggerArmor = {};

        int16_t SwordArmor = {};

        int16_t MaceArmor = {};

        int16_t AxeArmor = {};

        int16_t SpearArmor = {};

        int16_t BowArmor = {};

        uint8_t FireDamage = {};

        uint8_t IceDamage = {};

        uint8_t LightningDamage = {};

        uint8_t PoisonDamage = {};

        uint8_t HpDrain = {};

        uint8_t MpDamage = {};

        uint8_t MpDrain = {};

        uint8_t MirrorDamage = {};

        uint8_t DropRate = {};

        int16_t StrengthBonus = {};

        int16_t StaminaBonus = {};

        int16_t DexterityBonus = {};

        int16_t IntelligenceBonus = {};

        int16_t CharismaBonus = {};

        int16_t MaxHpBonus = {};

        int16_t MaxMpBonus = {};

        int16_t FireResist = {};

        int16_t ColdResist = {};

        int16_t LightningResist = {};

        int16_t MagicResist = {};

        int16_t PoisonResist = {};

        int16_t CurseResist = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class ItemExchange 
    {
    public:
        using BinderType = ebenezer_binder::ItemExchange;

        int32_t Index = {};

        int16_t NpcNumber = {};

        uint8_t RandomFlag = {};

        int32_t OriginItemNumber[5] = {};
 

        int16_t OriginItemCount[5] = {};
 

        int32_t ExchangeItemNumber[5] = {};
 

        int16_t ExchangeItemCount[5] = {};
 

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class ItemUpgrade 
    {
    public:
        using BinderType = ebenezer_binder::ItemUpgrade;

        int32_t Index = {};

        int16_t NpcNumber = {};

        int16_t OriginType = {};

        int16_t OriginItem = {};

        int32_t RequiredItem[8] = {};
 

        int32_t RequiredCoins = {};

        uint8_t RateType = {};

        int16_t GenRate = {};

        int16_t GiveItem = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class Knights 
    {
    public:
        using BinderType = ebenezer_binder::Knights;

        int16_t ID = {};

        uint8_t Flag = {};

        uint8_t Nation = {};

        uint8_t Ranking = {};

        std::string Name;

        int16_t Members = {};

        std::string Chief;

        std::optional<std::string> ViceChief1;

        std::optional<std::string> ViceChief2;

        std::optional<std::string> ViceChief3;

        std::optional<std::string> EnemyName;

        uint8_t OldWarResult = {};

        int32_t WarEnemyId = {};

        int32_t Victory = {};

        int32_t Lose = {};

        int64_t Gold = {};

        int16_t Domination = {};

        int32_t Points = {};

        int16_t MarkVersion = {};

        int16_t MarkLength = {};

        std::optional<std::vector<uint8_t>> Mark;

        uint8_t SiegeFlag = {};

        int16_t AllianceKnights = {};

        int16_t Cape = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class KnightsAlliance 
    {
    public:
        using BinderType = ebenezer_binder::KnightsAlliance;

        int16_t MainAllianceKnights = {};

        int16_t SubAllianceKnights = {};

        int16_t MercenaryClan1 = {};

        int16_t MercenaryClan2 = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class KnightsCape 
    {
    public:
        using BinderType = ebenezer_binder::KnightsCape;

        int16_t CapeIndex = {};

        int32_t BuyPrice = {};

        int32_t Duration = {};

        uint8_t Grade = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class KnightsRating 
    {
    public:
        using BinderType = ebenezer_binder::KnightsRating;

        int32_t Rank = {};

        int16_t Index = {};

        std::string Name;

        int32_t Points = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class KnightsSiegeWarfare 
    {
    public:
        using BinderType = ebenezer_binder::KnightsSiegeWarfare;

        int16_t CastleIndex = {};

        int16_t MasterKnights = {};

        uint8_t SiegeType = {};

        uint8_t WarDay = {};

        uint8_t WarHour = {};

        uint8_t WarMinute = {};

        int16_t ChallengeList1 = {};

        int16_t ChallengeList2 = {};

        int16_t ChallengeList3 = {};

        int16_t ChallengeList4 = {};

        int16_t ChallengeList5 = {};

        int16_t ChallengeList6 = {};

        int16_t ChallengeList7 = {};

        int16_t ChallengeList8 = {};

        int16_t ChallengeList9 = {};

        int16_t ChallengeList10 = {};

        uint8_t WarRequestDay = {};

        uint8_t WarRequestTime = {};

        uint8_t WarRequestMinute = {};

        uint8_t GuerrillaWarDay = {};

        uint8_t GuerrillaWarTime = {};

        uint8_t GuerrillaWarMinute = {};

        std::optional<std::vector<uint8_t>> ChallengeList;

        int16_t MoradonTariff = {};

        int16_t DelosTariff = {};

        int32_t DungeonCharge = {};

        int32_t MoradonTax = {};

        int32_t DelosTax = {};

        int16_t RequestList1 = {};

        int16_t RequestList2 = {};

        int16_t RequestList3 = {};

        int16_t RequestList4 = {};

        int16_t RequestList5 = {};

        int16_t RequestList6 = {};

        int16_t RequestList7 = {};

        int16_t RequestList8 = {};

        int16_t RequestList9 = {};

        int16_t RequestList10 = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class KnightsUser 
    {
    public:
        using BinderType = ebenezer_binder::KnightsUser;

        int16_t KnightsId = {};

        std::string UserId;

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        std::tuple<const int16_t&, const std::string&> MapKey() const;
 
    };

    class LevelUp 
    {
    public:
        using BinderType = ebenezer_binder::LevelUp;

        uint8_t Level = {};

        int32_t RequiredExp = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const uint8_t& MapKey() const;
 
    };

    class Magic 
    {
    public:
        using BinderType = ebenezer_binder::Magic;

        int32_t ID = {};

        uint8_t BeforeAction = {};

        uint8_t TargetAction = {};

        uint8_t SelfEffect = {};

        uint8_t FlyingEffect = {};

        int16_t TargetEffect = {};

        uint8_t Moral = {};

        int16_t SkillLevel = {};

        int16_t Skill = {};

        int16_t ManaCost = {};

        int16_t HpCost = {};

        uint8_t ItemGroup = {};

        int32_t UseItem = {};

        uint8_t CastTime = {};

        uint8_t RecastTime = {};

        uint8_t SuccessRate = {};

        uint8_t Type1 = {};

        uint8_t Type2 = {};

        int16_t Range = {};

        uint8_t Etc = {};

        int32_t Event = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType1 
    {
    public:
        using BinderType = ebenezer_binder::MagicType1;

        int32_t ID = {};

        uint8_t Type = {};

        enum class EnumType
        {
            Normal = 0, 
            AlwaysHit = 1, 
            IgnoreDefense = 2 
        };

        int16_t HitRateMod = {};

        int16_t DamageMod = {};

        int16_t AddDamage = {};

        uint8_t Delay = {};

        uint8_t ComboType = {};

        uint8_t ComboCount = {};

        int16_t ComboDamage = {};

        int16_t Range = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType2 
    {
    public:
        using BinderType = ebenezer_binder::MagicType2;

        int32_t ID = {};

        uint8_t HitType = {};

        enum class EnumHitType
        {
            Normal = 0, 
            Seeking = 0 
        };

        int16_t HitRateMod = {};

        int16_t DamageMod = {};

        int16_t RangeMod = {};

        uint8_t NeedArrow = {};

        int16_t AddDamagePlus = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType3 
    {
    public:
        using BinderType = ebenezer_binder::MagicType3;

        int32_t ID = {};

        uint8_t Radius = {};

        int16_t Angle = {};

        uint8_t DirectType = {};

        enum class EnumDirectType
        {
            Unknown0 = 0, 
            FlatHp = 1, 
            FlatMana = 2, 
            FlatDurability = 4, 
            Unknown5 = 5, 
            AbsorbHp = 8, 
            PercentHp = 9, 
            Unknown11 = 11, 
            Unknown12 = 12, 
            Unknown255 = 255 
        };

        int16_t FirstDamage = {};

        int16_t EndDamage = {};

        int16_t TimeDamage = {};

        uint8_t Duration = {};

        uint8_t Attribute = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType4 
    {
    public:
        using BinderType = ebenezer_binder::MagicType4;

        int32_t ID = {};

        uint8_t BuffType = {};

        enum class EnumBuffType
        {
            None = 0,
            HealthMana = 1, 
            Armor = 2, 
            Size = 3, 
            AttackPower = 4, 
            AttackSpeed = 5, 
            MovementSpeed = 6, 
            Stats = 7, 
            Resistance = 8, 
            HitChance = 9, 
            MagicPower = 10, 
            Experience = 11, 
            Weight = 12, 
            WeaponEnchant = 13, 
            ArmorEnchant = 14 
        };

        uint8_t Radius = {};

        int16_t Duration = {};

        uint8_t AttackSpeed = {};

        uint8_t Speed = {};

        int16_t Armor = {};

        int16_t ArmorPercent = {};

        uint8_t AttackPower = {};

        uint8_t MagicPower = {};

        int16_t MaxHp = {};

        int16_t MaxHpPercent = {};

        int16_t MaxMp = {};

        int16_t MaxMpPercent = {};

        uint8_t HitRate = {};

        int16_t AvoidRate = {};

        int16_t Strength = {};

        int16_t Stamina = {};

        int16_t Dexterity = {};

        int16_t Intelligence = {};

        int16_t Charisma = {};

        uint8_t FireResist = {};

        uint8_t ColdResist = {};

        uint8_t LightningResist = {};

        uint8_t MagicResist = {};

        uint8_t DiseaseResist = {};

        uint8_t PoisonResist = {};

        uint8_t ExpPercent = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType5 
    {
    public:
        using BinderType = ebenezer_binder::MagicType5;

        int32_t ID = {};

        uint8_t Type = {};

        enum class EnumType
        {
            CureDisease = 1, 
            CureCurse = 2, 
            Resurrection = 3, 
            Resurrection4 = 4, 
            Unknown5 = 5 
        };

        uint8_t ExpRecover = {};

        int16_t NeedStone = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType6 
    {
    public:
        using BinderType = ebenezer_binder::MagicType6;

        int32_t ID = {};

        int16_t Size = {};

        int16_t TransformId = {};

        int16_t Duration = {};

        int16_t MaxHp = {};

        int16_t MaxMp = {};

        uint8_t Speed = {};

        int16_t AttackSpeed = {};

        int16_t TotalHit = {};

        int16_t TotalArmor = {};

        int16_t TotalHitRate = {};

        int16_t TotalEvasionRate = {};

        int16_t TotalFireResist = {};

        int16_t TotalColdResist = {};

        int16_t TotalLightningResist = {};

        int16_t TotalMagicResist = {};

        int16_t TotalDiseaseResist = {};

        int16_t TotalPoisonResist = {};

        int16_t Class = {};

        uint8_t UserSkillUse = {};

        uint8_t NeedItem = {};

        uint8_t SkillSuccessRate = {};

        uint8_t MonsterFriendly = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType7 
    {
    public:
        using BinderType = ebenezer_binder::MagicType7;

        int32_t ID = {};

        uint8_t ValidGroup = {};

        uint8_t NationChange = {};

        int16_t MonsterNumber = {};

        uint8_t TargetChange = {};

        enum class EnumTargetChange
        {
            Provoke = 0, 
            Sleep = 1 
        };

        uint8_t StateChange = {};

        uint8_t Radius = {};

        int16_t HitRate = {};

        int16_t Duration = {};

        int16_t Damage = {};

        uint8_t Vision = {};

        int32_t NeedItem = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType8 
    {
    public:
        using BinderType = ebenezer_binder::MagicType8;

        int32_t ID = {};

        uint8_t Target = {};

        int16_t Radius = {};

        uint8_t WarpType = {};

        enum class EnumWarpType
        {
            Gate = 1, 
            SummonFriendly = 12, 
            SummonMonster = 21, 
            TeleportToFriendly = 25 
        };

        int16_t ExpRecover = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MagicType9 
    {
    public:
        using BinderType = ebenezer_binder::MagicType9;

        int32_t ID = {};

        uint8_t ValidGroup = {};

        uint8_t NationChange = {};

        int16_t MonsterNumber = {};

        uint8_t TargetChange = {};

        uint8_t StateChange = {};

        int16_t Radius = {};

        int16_t HitRate = {};

        int16_t Duration = {};

        int16_t AddDamage = {};

        int16_t Vision = {};

        int32_t NeedItem = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class MonsterChallenge 
    {
    public:
        using BinderType = ebenezer_binder::MonsterChallenge;

        int16_t Index = {};

        uint8_t StartTime1 = {};

        uint8_t StartTime2 = {};

        uint8_t StartTime3 = {};

        uint8_t LevelMin = {};

        uint8_t LevelMax = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class MonsterChallengeSummonList 
    {
    public:
        using BinderType = ebenezer_binder::MonsterChallengeSummonList;

        int16_t Index = {};

        uint8_t Level = {};

        uint8_t Stage = {};

        uint8_t StageLevel = {};

        int16_t Time = {};

        int16_t MonsterId = {};

        int16_t Count = {};

        int16_t PosX = {};

        int16_t PosZ = {};

        uint8_t Range = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class RentalItem 
    {
    public:
        using BinderType = ebenezer_binder::RentalItem;

        int32_t RentalIndex = {};

        int32_t ItemIndex = {};

        int16_t Durability = {};

        int64_t SerialNumber = {};

        uint8_t RegType = {};

        uint8_t ItemType = {};

        uint8_t Class = {};

        int16_t RentalTime = {};

        int32_t RentalMoney = {};

        std::string LenderCharId;

        std::string LenderAccountId;

        std::optional<std::string> BorrowerCharId;

        std::optional<std::string> BorrowerAccountId;

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class ServerResource 
    {
    public:
        using BinderType = ebenezer_binder::ServerResource;

        int32_t ResourceId = {};

        std::string Resource;

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class StartPosition 
    {
    public:
        using BinderType = ebenezer_binder::StartPosition;

        int16_t ZoneId = {};

        int16_t KarusX = {};

        int16_t KarusZ = {};

        int16_t ElmoX = {};

        int16_t ElmoZ = {};

        uint8_t RangeX = {};

        uint8_t RangeZ = {};

        int16_t KarusGateX = {};

        int16_t KarusGateZ = {};

        int16_t ElmoGateX = {};

        int16_t ElmoGateZ = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class UserKnightsRank 
    {
    public:
        using BinderType = ebenezer_binder::UserKnightsRank;

        int16_t Index = {};

        std::optional<std::string> ElmoUserId;

        std::optional<std::string> KarusUserId;

        int32_t Money = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class UserPersonalRank 
    {
    public:
        using BinderType = ebenezer_binder::UserPersonalRank;

        int16_t Rank = {};

        std::optional<std::string> ElmoUserId;

        std::optional<std::string> KarusUserId;

        int32_t Salary = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };

    class WebpageAddress 
    {
    public:
        using BinderType = ebenezer_binder::WebpageAddress;

        int32_t Index = {};

        std::string WebPageAddress;

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int32_t& MapKey() const;
 
    };

    class ZoneInfo 
    {
    public:
        using BinderType = ebenezer_binder::ZoneInfo;

        uint8_t ServerId = {};

        int16_t ZoneId = {};

        std::string Name;

        int32_t InitX = {};

        int32_t InitZ = {};

        int32_t InitY = {};

        uint8_t Type = {};

        uint8_t RoomEvent = {};

        static const std::string& TableName();

        static const std::unordered_set<std::string>& ColumnNames();

        static const std::vector<std::string>& OrderedColumnNames();

        static const std::unordered_set<std::string>& BlobColumns();

        static modelUtil::DbType DbType();

        static const std::vector<std::string>& PrimaryKey();

        const int16_t& MapKey() const;
 
    };
}
 
#endif // EBENEZER_MODEL_EBENEZERMODEL_H