FullModel.h

#ifndef FULL_MODEL_FULLMODEL_H
#define FULL_MODEL_FULLMODEL_H
 
#pragma once
 
#include <ModelUtil/ModelUtil.h>
#include <cstdint>
#include <ctime>
#include <optional>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
 
namespace full_binder
{
    class AccountChar;
    class Battle;
    class Coefficient;
    class Concurrent;
    class CopySerialItem;
    class CopyTest;
    class CouponSerialList;
    class CurrentUser;
    class Event;
    class EventTrigger;
    class FriendList;
    class HacktoolUserLog;
    class HeroUser;
    class Home;
    class Item;
    class ItemExchange;
    class ItemGroup;
    class ItemUpgrade;
    class ItemUpProbability;
    class Monster;
    class MonsterItem;
    class Npc;
    class NpcItem;
    class NpcMoveItem;
    class NpcPos;
    class KingBallotBox;
    class KingCandidacyNoticeBoard;
    class KingElectionList;
    class KingSystem;
    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 MakeDefensive;
    class MakeItem;
    class MakeItemGradeCode;
    class MakeItemGroup;
    class MakeItemRareCode;
    class MakeWeapon;
    class MonsterChallenge;
    class MonsterChallengeSummonList;
    class MonsterItemTest;
    class MonsterSummonList;
    class ProgramListLog;
    class RentalItem;
    class RentalItemList;
    class ServerResource;
    class StartPosition;
    class TbUser;
    class UserEditor;
    class UserEditorItem;
    class UserKnightsRank;
    class UserPersonalRank;
    class UserRentalItem;
    class UserSavedMagic;
    class UserData;
    class UserDataSkillShortcut;
    class Version;
    class Warehouse;
    class WebItemMall;
    class WebItemMallLog;
    class WebpageAddress;
    class ZoneInfo;
}
 
namespace full_model
{
    class AccountChar 
    {
    public:
        using BinderType = full_binder::AccountChar;

        std::string AccountId;

        uint8_t Nation = {};

        uint8_t CharNum = {};

        std::optional<std::string> CharId1;

        std::optional<std::string> CharId2;

        std::optional<std::string> CharId3;

        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 std::string& MapKey() const;
 
    };

    class Battle 
    {
    public:
        using BinderType = full_binder::Battle;

        int16_t Index = {};

        uint8_t Nation = {};

        std::optional<std::string> UserName;

        uint8_t ElmoArea = {};

        uint8_t KarusArea = {};

        uint8_t ElmoAdvantage = {};

        uint8_t KarusAdvantage = {};

        uint8_t Area1 = {};

        uint8_t Area2 = {};

        uint8_t Area3 = {};

        uint8_t Area4 = {};

        uint8_t Area5 = {};

        uint8_t Area6 = {};

        uint8_t Area7 = {};

        uint8_t Area8 = {};

        uint8_t Area9 = {};

        uint8_t Area10 = {};

        uint8_t Area11 = {};

        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 = full_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 Concurrent 
    {
    public:
        using BinderType = full_binder::Concurrent;

        uint8_t ServerId = {};

        int16_t Zone1Count = {};

        int16_t Zone2Count = {};

        int16_t Zone3Count = {};

        std::optional<std::string> Bz;

        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 CopySerialItem 
    {
    public:
        using BinderType = full_binder::CopySerialItem;

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

        std::optional<uint8_t> Type;

        std::optional<int16_t> Pos;

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

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

        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 CopyTest 
    {
    public:
        using BinderType = full_binder::CopyTest;

        int64_t ItemSerial = {};

        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 CouponSerialList 
    {
    public:
        using BinderType = full_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 CurrentUser 
    {
    public:
        using BinderType = full_binder::CurrentUser;

        int32_t ServerId = {};

        std::string ServerIP;

        std::string AccountId;

        std::string CharId;

        std::string ClientIP;

        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 std::string& MapKey() const;
 
    };

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

        uint8_t ZoneNumber = {};

        int16_t EventNumber = {};

        uint8_t EventType = {};

        std::optional<std::string> Condition1;

        std::optional<std::string> Condition2;

        std::optional<std::string> Condition3;

        std::optional<std::string> Condition4;

        std::optional<std::string> Condition5;

        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 = full_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 FriendList 
    {
    public:
        using BinderType = full_binder::FriendList;

        std::string UserId;

        std::optional<std::string> Friend1;

        std::optional<std::string> Friend2;

        std::optional<std::string> Friend3;

        std::optional<std::string> Friend4;

        std::optional<std::string> Friend5;

        std::optional<std::string> Friend6;

        std::optional<std::string> Friend7;

        std::optional<std::string> Friend8;

        std::optional<std::string> Friend9;

        std::optional<std::string> Friend10;

        std::optional<std::string> Friend11;

        std::optional<std::string> Friend12;

        std::optional<std::string> Friend13;

        std::optional<std::string> Friend14;

        std::optional<std::string> Friend15;

        std::optional<std::string> Friend16;

        std::optional<std::string> Friend17;

        std::optional<std::string> Friend18;

        std::optional<std::string> Friend19;

        std::optional<std::string> Friend20;

        std::optional<std::string> Friend21;

        std::optional<std::string> Friend22;

        std::optional<std::string> Friend23;

        std::optional<std::string> Friend24;

        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 std::string& MapKey() const;
 
    };

    class HacktoolUserLog 
    {
    public:
        using BinderType = full_binder::HacktoolUserLog;

        std::string AccountId;

        std::string CharId;

        std::string HackToolName;

        std::time_t WriteTime;

        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 HeroUser 
    {
    public:
        using BinderType = full_binder::HeroUser;

        int16_t Index = {};

        std::optional<std::string> UserId;

        std::optional<std::string> Nation;

        std::optional<std::string> ClassName;

        std::optional<std::string> Achievement;

        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 Home 
    {
    public:
        using BinderType = full_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 = full_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 MaxLevel = {};

        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 = full_binder::ItemExchange;

        int32_t Index = {};

        int16_t NpcNumber = {};

        std::string NpcName;

        std::string Note;

        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 ItemGroup 
    {
    public:
        using BinderType = full_binder::ItemGroup;

        int16_t Group = {};

        std::optional<std::string> Name;

        int32_t Item1 = {};

        int32_t Item2 = {};

        int32_t Item3 = {};

        int32_t Item4 = {};

        int32_t Item5 = {};

        int32_t Item6 = {};

        int32_t Item7 = {};

        int32_t Item8 = {};

        int32_t Item9 = {};

        int32_t Item10 = {};

        int32_t Item11 = {};

        int32_t Item12 = {};

        int32_t Item13 = {};

        int32_t Item14 = {};

        int32_t Item15 = {};

        int32_t Item16 = {};

        int32_t Item17 = {};

        int32_t Item18 = {};

        int32_t Item19 = {};

        int32_t Item20 = {};

        int32_t Item21 = {};

        int32_t Item22 = {};

        int32_t Item23 = {};

        int32_t Item24 = {};

        int32_t Item25 = {};

        int32_t Item26 = {};

        int32_t Item27 = {};

        int32_t Item28 = {};

        int32_t Item29 = {};

        int32_t Item30 = {};

        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 ItemUpgrade 
    {
    public:
        using BinderType = full_binder::ItemUpgrade;

        int32_t Index = {};

        int16_t NpcNumber = {};

        std::string Name;

        std::string Note;

        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 ItemUpProbability 
    {
    public:
        using BinderType = full_binder::ItemUpProbability;

        uint8_t Type = {};

        int16_t MaxSuccess = {};

        int16_t MaxFail = {};

        int16_t CurrentSuccess = {};

        int16_t CurrentFailure = {};

        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 Monster 
    {
    public:
        using BinderType = full_binder::Monster;

        int16_t MonsterId = {};

        std::optional<std::string> Name;

        int16_t PictureId = {};

        int16_t Size = {};

        int32_t Weapon1 = {};

        int32_t Weapon2 = {};

        uint8_t Group = {};

        uint8_t ActType = {};

        uint8_t Type = {};

        enum class EnumType
        {
            Monster = 0,
            Npc = 1,
            Event = 2,
            Unknown3 = 3,
            Unknown4 = 4,
            Trap = 5,
            RangedOrc = 6,
            Unknown9 = 9
        };

        uint8_t Family = {};

        uint8_t Rank = {};

        uint8_t Title = {};

        int32_t SellingGroup = {};

        int16_t Level = {};

        int32_t Exp = {};

        int32_t Loyalty = {};

        int32_t HitPoints = {};

        int16_t ManaPoints = {};

        int16_t Attack = {};

        int16_t Armor = {};

        int16_t HitRate = {};

        int16_t EvadeRate = {};

        int16_t Damage = {};

        int16_t AttackDelay = {};

        uint8_t WalkSpeed = {};

        uint8_t RunSpeed = {};

        int16_t StandTime = {};

        int32_t Magic1 = {};

        int32_t Magic2 = {};

        int32_t Magic3 = {};

        int16_t FireResist = {};

        int16_t ColdResist = {};

        int16_t LightningResist = {};

        int16_t MagicResist = {};

        int16_t DiseaseResist = {};

        int16_t PoisonResist = {};

        int16_t LightResist = {};

        int16_t Bulk = {};

        uint8_t AttackRange = {};

        uint8_t SearchRange = {};

        uint8_t TracingRange = {};

        int32_t Money = {};

        int16_t Item = {};

        uint8_t DirectAttack = {};

        uint8_t MagicAttack = {};

        uint8_t MoneyType = {};

        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 MonsterItem 
    {
    public:
        using BinderType = full_binder::MonsterItem;

        int16_t MonsterId = {};

        int32_t ItemId[5] = {};
 

        int16_t DropChance[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 int16_t& MapKey() const;
 
    };

    class Npc 
    {
    public:
        using BinderType = full_binder::Npc;

        int16_t NpcId = {};

        std::optional<std::string> Name;

        int16_t PictureId = {};

        int16_t Size = {};

        int32_t Weapon1 = {};

        int32_t Weapon2 = {};

        uint8_t Group = {};

        uint8_t ActType = {};

        uint8_t Type = {};

        enum class EnumType
        {
            Monster = 0,
            Npc = 1,
            Event = 2,
            Unknown3 = 3,
            Unknown4 = 4,
            Trap = 5,
            RangedOrc = 6,
            Unknown9 = 9
        };

        uint8_t Family = {};

        uint8_t Rank = {};

        uint8_t Title = {};

        int32_t SellingGroup = {};

        int16_t Level = {};

        int32_t Exp = {};

        int32_t Loyalty = {};

        int32_t HitPoints = {};

        int16_t ManaPoints = {};

        int16_t Attack = {};

        int16_t Armor = {};

        int16_t HitRate = {};

        int16_t EvadeRate = {};

        int16_t Damage = {};

        int16_t AttackDelay = {};

        uint8_t WalkSpeed = {};

        uint8_t RunSpeed = {};

        int16_t StandTime = {};

        int32_t Magic1 = {};

        int32_t Magic2 = {};

        int32_t Magic3 = {};

        int16_t FireResist = {};

        int16_t ColdResist = {};

        int16_t LightningResist = {};

        int16_t MagicResist = {};

        int16_t DiseaseResist = {};

        int16_t PoisonResist = {};

        int16_t LightResist = {};

        int16_t Bulk = {};

        uint8_t AttackRange = {};

        uint8_t SearchRange = {};

        uint8_t TracingRange = {};

        int32_t Money = {};

        int16_t Item = {};

        uint8_t DirectAttack = {};

        uint8_t MagicAttack = {};

        uint8_t MoneyType = {};

        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 NpcItem 
    {
    public:
        using BinderType = full_binder::NpcItem;

        int16_t NpcId = {};

        int32_t ItemId1 = {};

        std::optional<int16_t> DropChance[5];
 

        std::optional<int32_t> ItemId2;

        std::optional<int32_t> ItemId3;

        std::optional<int32_t> ItemId4;

        std::optional<int32_t> ItemId5;

        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 NpcMoveItem 
    {
    public:
        using BinderType = full_binder::NpcMoveItem;

        int16_t CastleIndex = {};

        std::optional<int32_t> ChangeItem;

        std::optional<int32_t> ChangeId;

        std::optional<int32_t> MoveItem;

        std::optional<int16_t> MoveMinX;

        std::optional<int16_t> MoveMinY;

        std::optional<int16_t> MoveMaxX;

        std::optional<int16_t> MoveMaxY;

        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 NpcPos 
    {
    public:
        using BinderType = full_binder::NpcPos;

        int16_t ZoneId = {};

        int32_t NpcId = {};

        uint8_t ActType = {};

        uint8_t RegenType = {};

        uint8_t DungeonFamily = {};

        uint8_t SpecialType = {};

        uint8_t TrapNumber = {};

        int32_t LeftX = {};

        int32_t TopZ = {};

        int32_t RightX = {};

        int32_t BottomZ = {};

        int32_t LimitMinZ = {};

        int32_t LimitMinX = {};

        int32_t LimitMaxX = {};

        int32_t LimitMaxZ = {};

        uint8_t NumNpc = {};

        int16_t RespawnTime = {};

        int32_t Direction = {};

        uint8_t PathPointCount = {};

        std::optional<std::string> Path;

        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 KingBallotBox 
    {
    public:
        using BinderType = full_binder::KingBallotBox;

        std::string AccountId;

        std::string CharId;

        uint8_t Nation = {};

        std::string CandidateId;

        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 KingCandidacyNoticeBoard 
    {
    public:
        using BinderType = full_binder::KingCandidacyNoticeBoard;

        std::string CandidateId;

        uint8_t Nation = {};

        int16_t NoticeLength = {};

        std::vector<uint8_t> Notice;

        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 std::string& MapKey() const;
 
    };

    class KingElectionList 
    {
    public:
        using BinderType = full_binder::KingElectionList;

        uint8_t Type = {};

        uint8_t Nation = {};

        int16_t Knights = {};

        std::string Name;

        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();
 
    };

    class KingSystem 
    {
    public:
        using BinderType = full_binder::KingSystem;

        uint8_t Nation = {};

        uint8_t Type = {};

        int16_t Year = {};

        uint8_t Month = {};

        uint8_t Day = {};

        uint8_t Hour = {};

        uint8_t Minute = {};

        uint8_t ImType = {};

        int16_t ImYear = {};

        uint8_t ImMonth = {};

        uint8_t ImDay = {};

        uint8_t ImHour = {};

        uint8_t ImMinute = {};

        uint8_t NoahEvent = {};

        uint8_t NoahEventDay = {};

        uint8_t NoahEventHour = {};

        uint8_t NoahEventMinute = {};

        int16_t NoahEventDuration = {};

        uint8_t ExpEvent = {};

        uint8_t ExpEventDay = {};

        uint8_t ExpEventHour = {};

        uint8_t ExpEventMinute = {};

        int16_t ExpEventDuration = {};

        int32_t Tribute = {};

        uint8_t TerritoryTariff = {};

        int32_t TerritoryTax = {};

        int32_t NationalTreasury = {};

        std::optional<std::string> KingName;

        std::optional<std::string> ImRequestId;

        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 Knights 
    {
    public:
        using BinderType = full_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 = {};

        std::time_t CreateTime;

        int16_t MarkVersion = {};

        int16_t MarkLength = {};

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

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

        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 = full_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 = full_binder::KnightsCape;

        int16_t CapeIndex = {};

        std::string Name;

        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 = full_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 = full_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 = full_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 = full_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 = full_binder::Magic;

        int32_t ID = {};

        std::optional<std::string> EnglishName;

        std::optional<std::string> KoreanName;

        std::optional<std::string> Description;

        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 = full_binder::MagicType1;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType2;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType3;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType4;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType5;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType6;

        int32_t ID = {};

        std::string Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType7;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Note;

        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 = full_binder::MagicType8;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 = full_binder::MagicType9;

        int32_t ID = {};

        std::optional<std::string> Name;

        std::optional<std::string> Description;

        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 MakeDefensive 
    {
    public:
        using BinderType = full_binder::MakeDefensive;

        uint8_t Level = {};

        int16_t Class1 = {};

        int16_t Class2 = {};

        int16_t Class3 = {};

        int16_t Class4 = {};

        int16_t Class5 = {};

        int16_t Class6 = {};

        int16_t Class7 = {};

        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 MakeItem 
    {
    public:
        using BinderType = full_binder::MakeItem;

        int16_t Index = {};

        std::optional<std::string> ItemInfo;

        int32_t ItemCode = {};

        uint8_t ItemLevel = {};

        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 MakeItemGradeCode 
    {
    public:
        using BinderType = full_binder::MakeItemGradeCode;

        uint8_t ItemIndex = {};

        int16_t Grade[9] = {};
 

        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 MakeItemGroup 
    {
    public:
        using BinderType = full_binder::MakeItemGroup;

        int32_t ItemGroupNumber = {};

        int32_t Item[30] = {};
 

        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 MakeItemRareCode 
    {
    public:
        using BinderType = full_binder::MakeItemRareCode;

        uint8_t LevelGrade = {};

        int16_t UpgradeItem = {};

        int16_t RareItem = {};

        int16_t MagicItem = {};

        int16_t GeneralItem = {};

        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 MakeWeapon 
    {
    public:
        using BinderType = full_binder::MakeWeapon;

        uint8_t Level = {};

        int16_t Class[12] = {};
 

        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 MonsterChallenge 
    {
    public:
        using BinderType = full_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 = full_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 MonsterItemTest 
    {
    public:
        using BinderType = full_binder::MonsterItemTest;

        int16_t Index = {};

        std::optional<int32_t> Item1;

        std::optional<int16_t> Percent1;

        std::optional<int32_t> Item2;

        std::optional<int16_t> Percent2;

        std::optional<int32_t> Item3;

        std::optional<int16_t> Percent3;

        std::optional<int32_t> Item4;

        std::optional<int16_t> Percent4;

        std::optional<int32_t> Item5;

        std::optional<int16_t> Percent5;

        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 MonsterSummonList 
    {
    public:
        using BinderType = full_binder::MonsterSummonList;

        int16_t MonsterId = {};

        std::string Name;

        int16_t Level = {};

        int16_t Probability = {};

        uint8_t Type = {};

        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 ProgramListLog 
    {
    public:
        using BinderType = full_binder::ProgramListLog;

        int32_t Id = {};

        std::string AccountId;

        std::string CharId;

        std::string HackToolName;

        std::time_t WriteTime;

        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 RentalItem 
    {
    public:
        using BinderType = full_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;

        std::optional<std::time_t> LendTime;

        std::time_t RegisterTime;

        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 RentalItemList 
    {
    public:
        using BinderType = full_binder::RentalItemList;

        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;

        std::optional<std::time_t> LendTime;

        std::time_t RegisterTime;

        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 ServerResource 
    {
    public:
        using BinderType = full_binder::ServerResource;

        int32_t ResourceId = {};

        std::string Name;

        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 = full_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 TbUser 
    {
    public:
        using BinderType = full_binder::TbUser;

        std::string AccountId;

        std::string Password;

        std::string SocNo;

        std::string Email;

        uint8_t Authority = {};

        std::time_t PremiumExpire;

        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 std::string& MapKey() const;
 
    };

    class UserEditor 
    {
    public:
        using BinderType = full_binder::UserEditor;

        std::string CharId;

        std::string AccountId;

        std::string OpId;

        std::string OpIP;

        std::vector<uint8_t> OldUserValue;

        std::vector<uint8_t> NewUserValue;

        std::vector<uint8_t> OldUserSkill;

        std::vector<uint8_t> NewUserSkill;

        std::vector<uint8_t> OldUserItem;

        std::vector<uint8_t> NewUserItem;

        std::vector<uint8_t> OldWarehouseValue;

        std::vector<uint8_t> NewWarehouseValue;

        std::vector<uint8_t> OldWarehouseItem;

        std::vector<uint8_t> NewWarehouseItem;

        std::time_t EditorTime;

        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 UserEditorItem 
    {
    public:
        using BinderType = full_binder::UserEditorItem;

        std::string CharId;

        std::string AccountId;

        std::string OpId;

        std::string OpIP;

        int16_t DbIndex = {};

        int16_t Pos = {};

        uint8_t Type = {};

        int32_t ItemId1 = {};

        int32_t ItemId2 = {};

        std::optional<std::time_t> UpdateTime;

        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 UserKnightsRank 
    {
    public:
        using BinderType = full_binder::UserKnightsRank;

        int16_t Index = {};

        std::string Name;

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

        std::optional<std::string> ElmoKnightsName;

        std::optional<int32_t> ElmoLoyalty;

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

        std::optional<std::string> KarusKnightsName;

        std::optional<int32_t> KarusLoyalty;

        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 = full_binder::UserPersonalRank;

        int16_t Rank = {};

        std::string Position;

        int16_t ElmoUp = {};

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

        std::optional<int32_t> ElmoLoyaltyMonthly;

        int32_t ElmoCheck = {};

        int16_t KarusUp = {};

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

        std::optional<int32_t> KarusLoyaltyMonthly;

        int32_t KarusCheck = {};

        int32_t Salary = {};

        std::time_t UpdateDate;

        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 UserRentalItem 
    {
    public:
        using BinderType = full_binder::UserRentalItem;

        std::string UserId;

        std::string AccountId;

        uint8_t RentalType = {};

        uint8_t RegTime = {};

        int32_t RentalIndex = {};

        int32_t ItemIndex = {};

        int16_t Durability = {};

        int64_t SerialNumber = {};

        int32_t RentalMoney = {};

        int16_t RentalTime = {};

        int16_t DuringTime = {};

        std::optional<std::time_t> RentalTimestamp;

        std::optional<std::time_t> RegisterTime;

        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 UserSavedMagic 
    {
    public:
        using BinderType = full_binder::UserSavedMagic;

        std::string CharId;

        int32_t Skill1 = {};

        int16_t During1 = {};

        int32_t Skill2 = {};

        int16_t During2 = {};

        int32_t Skill3 = {};

        int16_t During3 = {};

        int32_t Skill4 = {};

        int16_t During4 = {};

        int32_t Skill5 = {};

        int16_t During5 = {};

        int32_t Skill6 = {};

        int16_t During6 = {};

        int32_t Skill7 = {};

        int16_t During7 = {};

        int32_t Skill8 = {};

        int16_t During8 = {};

        int32_t Skill9 = {};

        int16_t During9 = {};

        int32_t Skill10 = {};

        int16_t During10 = {};

        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 std::string& MapKey() const;
 
    };

    class UserData 
    {
    public:
        using BinderType = full_binder::UserData;

        std::string UserId;

        uint8_t Nation = {};

        uint8_t Race = {};

        enum class EnumRace
        {
            AechTaurek = 1, 
            Tuarek = 2, 
            WrinkleTuarek = 3, 
            PuriTuarek = 4, 
            Barbarian = 11, 
            ElMoradMale = 12, 
            ElMoradFemale = 13 
        };

        int16_t Class = {};

        enum class EnumClass
        {
            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 
        };

        uint8_t HairColor = {};

        uint8_t Rank = {};

        uint8_t Title = {};

        uint8_t Level = {};

        int32_t Exp = {};

        int32_t Loyalty = {};

        uint8_t Face = {};

        uint8_t City = {};

        int16_t KnightsId = {};

        uint8_t Fame = {};

        int16_t Hp = {};

        int16_t Mp = {};

        int16_t Sp = {};

        uint8_t Strength = {};

        uint8_t Stamina = {};

        uint8_t Dexterity = {};

        uint8_t Intelligence = {};

        uint8_t Charisma = {};

        uint8_t Authority = {};

        uint8_t StatPoints = {};

        int32_t Gold = {};

        uint8_t Zone = {};

        std::optional<int16_t> Bind;

        int32_t PosX = {};

        int32_t PosZ = {};

        int32_t PosY = {};

        int32_t DwTime = {};

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

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

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

        int16_t QuestCount = {};

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

        int32_t MannerPoint = {};

        int32_t LoyaltyMonthly = {};

        std::time_t CreateTime;

        std::optional<std::time_t> UpdateTime;

        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 std::string& MapKey() const;
 
    };

    class UserDataSkillShortcut 
    {
    public:
        using BinderType = full_binder::UserDataSkillShortcut;

        std::string CharId;

        int16_t Count = {};

        std::vector<uint8_t> SkillData;

        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 std::string& MapKey() const;
 
    };

    class Version 
    {
    public:
        using BinderType = full_binder::Version;

        int16_t Number = {};

        std::string FileName;

        std::string CompressName;

        int16_t HistoryVersion = {};

        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 Warehouse 
    {
    public:
        using BinderType = full_binder::Warehouse;

        std::string AccountId;

        int32_t Money = {};

        int32_t DwTime = {};

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

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

        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 std::string& MapKey() const;
 
    };

    class WebItemMall 
    {
    public:
        using BinderType = full_binder::WebItemMall;

        std::string AccountId;

        std::string CharId;

        int16_t ServerId = {};

        int32_t ItemId = {};

        int16_t ItemCount = {};

        std::time_t BuyTime;

        std::optional<std::string> ImgFileName;

        std::optional<std::string> ItemName;

        std::optional<int32_t> Price;

        std::optional<int32_t> PayType;

        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 WebItemMallLog 
    {
    public:
        using BinderType = full_binder::WebItemMallLog;

        std::string AccountId;

        std::string CharId;

        int16_t ServerId = {};

        int32_t ItemId = {};

        int16_t ItemCount = {};

        std::time_t BuyTime;

        std::optional<std::string> ImgFileName;

        std::optional<std::string> ItemName;

        std::optional<int32_t> Price;

        std::optional<int32_t> PayType;

        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 WebpageAddress 
    {
    public:
        using BinderType = full_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 = full_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 = {};

        std::optional<std::string> Bz;

        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 // FULL_MODEL_FULLMODEL_H