StoredProc.h

#ifndef STOREDPROC_STOREDPROC_H
#define STOREDPROC_STOREDPROC_H
 
#pragma once
 
#include <ModelUtil/ModelUtil.h>
#include <cstdint>
#include <detail/StoredProc/StoredProcedure.h>
#include <memory>
#include <nanodbc/nanodbc.h>
#include <string>
#include <vector>
 
namespace storedProc
{

    class AccountLogin : public detail::StoredProcedure
    {
    public:
        AccountLogin();
        AccountLogin(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* accountID, const char* password, int16_t* nRet) noexcept(false);

        ~AccountLogin();
    };

    class AccountLogout : public detail::StoredProcedure
    {
    public:
        AccountLogout();
        AccountLogout(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* accountID, const int32_t logoutCode, int16_t* nRet, 
            int16_t* nRet2) noexcept(false);

        ~AccountLogout();
    };

    class ChangeCastleCommerce : public detail::StoredProcedure
    {
    public:
        ChangeCastleCommerce();
        ChangeCastleCommerce(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t sCastleIndex, const uint8_t byType, const int32_t nMoradonTariff, 
            const int32_t nDelosTariff, const int32_t nMoney, const char* accountId, 
            const char* charId) noexcept(false);
    };

    class ChangeCopySerialItem : public detail::StoredProcedure
    {
    public:
        ChangeCopySerialItem();
        ChangeCopySerialItem(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class ChangeCopySerialItemTable : public detail::StoredProcedure
    {
    public:
        ChangeCopySerialItemTable();
        ChangeCopySerialItemTable(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class ChangeKnightsCape : public detail::StoredProcedure
    {
    public:
        ChangeKnightsCape();
        ChangeKnightsCape(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t KnightsIndex, const int16_t CapeIndex) noexcept(false);
    };

    class CheckKnights : public detail::StoredProcedure
    {
    public:
        CheckKnights();
        CheckKnights(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class ClearRemainUsers : public detail::StoredProcedure
    {
    public:
        ClearRemainUsers();
        ClearRemainUsers(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strServerIP) noexcept(false);
    };

    class CreateKnights : public detail::StoredProcedure
    {
    public:
        CreateKnights();
        CreateKnights(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, const int16_t index, const uint8_t nation, 
            const uint8_t community, const char* strName, const char* strChief) noexcept(false);

        ~CreateKnights();
    };

    class CreateKnights2 : public detail::StoredProcedure
    {
    public:
        CreateKnights2();
        CreateKnights2(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, int16_t* index, const uint8_t nation, 
            const uint8_t community, const char* strName, const char* strChief) noexcept(false);

        ~CreateKnights2();
    };

    class CreateNewChar : public detail::StoredProcedure
    {
    public:
        CreateNewChar();
        CreateNewChar(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, const char* AccountID, const uint8_t index, 
            const char* CharID, const uint8_t Race, const int16_t Class, 
            const uint8_t Hair, const uint8_t Face, const uint8_t Str, 
            const uint8_t Sta, const uint8_t Dex, const uint8_t Intel, 
            const uint8_t Cha) noexcept(false);

        ~CreateNewChar();
    };

    class DeleteFriendList : public detail::StoredProcedure
    {
    public:
        DeleteFriendList();
        DeleteFriendList(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strUserID, const char* strFriend, int16_t* nRet) noexcept(false);

        ~DeleteFriendList();
    };

    class DeleteKnights : public detail::StoredProcedure
    {
    public:
        DeleteKnights();
        DeleteKnights(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, const int16_t knightsindex) noexcept(false);

        ~DeleteKnights();
    };

    class EditerKnights : public detail::StoredProcedure
    {
    public:
        EditerKnights();
        EditerKnights(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class ExecKnightsUser : public detail::StoredProcedure
    {
    public:
        ExecKnightsUser();
        ExecKnightsUser(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class GivePremium : public detail::StoredProcedure
    {
    public:
        GivePremium();
        GivePremium(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strAccountID, const char* strUserID, const int32_t days) noexcept(false);
    };

    class InsertFriendList : public detail::StoredProcedure
    {
    public:
        InsertFriendList();
        InsertFriendList(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strUserID, const char* strFriend, int16_t* nRet) noexcept(false);

        ~InsertFriendList();
    };

    class InsertHacktoolUser : public detail::StoredProcedure
    {
    public:
        InsertHacktoolUser();
        InsertHacktoolUser(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, const char* CharID, const char* HackToolName) noexcept(false);
    };

    class InsertProgramCheckUser : public detail::StoredProcedure
    {
    public:
        InsertProgramCheckUser();
        InsertProgramCheckUser(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strAccountID, const char* strCharID, const char* HackToolName) noexcept(false);
    };

    class KingCandidacyNoticeBoardProc : public detail::StoredProcedure
    {
    public:
        KingCandidacyNoticeBoardProc();
        KingCandidacyNoticeBoardProc(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strUserID, const int16_t sNoticeLen, const uint8_t byNation, 
            const std::vector<uint8_t>& strNotice) noexcept(false);
    };

    class KingCandidacyRecommend : public detail::StoredProcedure
    {
    public:
        KingCandidacyRecommend();
        KingCandidacyRecommend(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* CharID_1, const char* CharID_2, const uint8_t nNation, 
            int16_t* nRet) noexcept(false);

        ~KingCandidacyRecommend();
    };

    class KingChangeTax : public detail::StoredProcedure
    {
    public:
        KingChangeTax();
        KingChangeTax(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const uint8_t byNation, const int32_t nKarusTax1, 
            const int32_t nKarusTax2, const int32_t nKarusTax3, const int32_t nElmoTax1, 
            const int32_t nElmoTax2, const int32_t nElmoTax3) noexcept(false);
    };

    class KingElectionProc : public detail::StoredProcedure
    {
    public:
        KingElectionProc();
        KingElectionProc(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strAccountID, const char* strCharID, const uint8_t byNation, 
            const char* strCandidacyID, int16_t* nRet) noexcept(false);

        ~KingElectionProc();
    };

    class KingImpeachmentElection : public detail::StoredProcedure
    {
    public:
        KingImpeachmentElection();
        KingImpeachmentElection(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byResult, const uint8_t byNation, const char* strAccountID, 
            const char* strCharID, int16_t* nRet) noexcept(false);

        ~KingImpeachmentElection();
    };

    class KingImpeachmentRequestElection : public detail::StoredProcedure
    {
    public:
        KingImpeachmentRequestElection();
        KingImpeachmentRequestElection(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t byType, const uint8_t byNation, const char* strUserID) noexcept(false);
    };

    class KingImpeachmentResult : public detail::StoredProcedure
    {
    public:
        KingImpeachmentResult();
        KingImpeachmentResult(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byNation, int16_t* nTotalMan, int16_t* nAgreeMan) noexcept(false);

        ~KingImpeachmentResult();
    };

    class KingInsertPrizeEvent : public detail::StoredProcedure
    {
    public:
        KingInsertPrizeEvent();
        KingInsertPrizeEvent(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const uint8_t byNation, const int32_t nAmount, 
            const char* strUserID) noexcept(false);
    };

    class KingUpdateElectionList : public detail::StoredProcedure
    {
    public:
        KingUpdateElectionList();
        KingUpdateElectionList(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byDBType, const uint8_t byType, const uint8_t byNation, 
            const int16_t nKnights, const int32_t nAmount, const char* strUserID) noexcept(false);
    };

    class KingUpdateElectionSchdule : public detail::StoredProcedure
    {
    public:
        KingUpdateElectionSchdule();
        KingUpdateElectionSchdule(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const uint8_t byNation, const int16_t sYear, 
            const uint8_t byMonth, const uint8_t byDay, const uint8_t byHour, 
            const uint8_t byMinute) noexcept(false);
    };

    class KingUpdateElectionStatus : public detail::StoredProcedure
    {
    public:
        KingUpdateElectionStatus();
        KingUpdateElectionStatus(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const uint8_t byNation) noexcept(false);
    };

    class KingUpdateImpeachmentStatus : public detail::StoredProcedure
    {
    public:
        KingUpdateImpeachmentStatus();
        KingUpdateImpeachmentStatus(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const uint8_t byNation, const int16_t sYear, 
            const uint8_t byMonth, const uint8_t byDay, const uint8_t byHour, 
            const uint8_t byMinute, const char* strUserID) noexcept(false);
    };

    class KingUpdateNoahOrExpEvent : public detail::StoredProcedure
    {
    public:
        KingUpdateNoahOrExpEvent();
        KingUpdateNoahOrExpEvent(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const uint8_t byNation, const uint8_t byAmount, 
            const uint8_t byDay, const uint8_t byHout, const uint8_t byMinute, 
            const int16_t sDurationTime) noexcept(false);
    };

    class KnightsRatingUpdate : public detail::StoredProcedure
    {
    public:
        KnightsRatingUpdate();
        KnightsRatingUpdate(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class LoadAccountCharid : public detail::StoredProcedure
    {
    public:
        LoadAccountCharid();
        LoadAccountCharid(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(int* returnValue, 
            const char* Accountid) noexcept(false);

        ~LoadAccountCharid();
    };

    class LoadCharInfo : public detail::StoredProcedure
    {
    public:
        LoadCharInfo();
        LoadCharInfo(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* CharId, int16_t* nRet) noexcept(false);

        ~LoadCharInfo();
    };

    class LoadKnightsMembers : public detail::StoredProcedure
    {
    public:
        LoadKnightsMembers();
        LoadKnightsMembers(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t knightsindex) noexcept(false);
    };

    class LoadPremiumServiceUser : public detail::StoredProcedure
    {
    public:
        LoadPremiumServiceUser();
        LoadPremiumServiceUser(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, int32_t* type, int32_t* days) noexcept(false);

        ~LoadPremiumServiceUser();
    };

    class LoadRentalData : public detail::StoredProcedure
    {
    public:
        LoadRentalData();
        LoadRentalData(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strAccountID) noexcept(false);
    };

    class LoadSavedMagic : public detail::StoredProcedure
    {
    public:
        LoadSavedMagic();
        LoadSavedMagic(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* CharId, int16_t* nRet) noexcept(false);

        ~LoadSavedMagic();
    };

    class LoadUserData : public detail::StoredProcedure
    {
    public:
        LoadUserData();
        LoadUserData(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, const char* id, int16_t* nRet) noexcept(false);

        ~LoadUserData();
    };

    class LoadWebItemmall : public detail::StoredProcedure
    {
    public:
        LoadWebItemmall();
        LoadWebItemmall(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strCharID) noexcept(false);
    };

    class NationSelect : public detail::StoredProcedure
    {
    public:
        NationSelect();
        NationSelect(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, const char* AccountID, const uint8_t Nation) noexcept(false);

        ~NationSelect();
    };

    class ProcInsertCurrentuser : public detail::StoredProcedure
    {
    public:
        ProcInsertCurrentuser();
        ProcInsertCurrentuser(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, const char* CharID, const int16_t nServerNo, 
            const char* strServerIP, const char* ClientIP, int16_t* nRet) noexcept(false);

        ~ProcInsertCurrentuser();
    };

    class RankKnights : public detail::StoredProcedure
    {
    public:
        RankKnights();
        RankKnights(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class RentalItemCancel : public detail::StoredProcedure
    {
    public:
        RentalItemCancel();
        RentalItemCancel(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, const char* CharID, const int32_t nRentalIndex, 
            const int32_t nItemNumber, int16_t* nRet) noexcept(false);

        ~RentalItemCancel();
    };

    class RentalItemDestory : public detail::StoredProcedure
    {
    public:
        RentalItemDestory();
        RentalItemDestory(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, const char* CharID, const int32_t nItemNumber, 
            const int32_t nRentalIndex, const int16_t nDurability, int16_t* nRet) noexcept(false);

        ~RentalItemDestory();
    };

    class RentalItemDurabilityUpdate : public detail::StoredProcedure
    {
    public:
        RentalItemDurabilityUpdate();
        RentalItemDurabilityUpdate(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int32_t nRentalIndex, const int32_t nDurability) noexcept(false);
    };

    class RentalItemLend : public detail::StoredProcedure
    {
    public:
        RentalItemLend();
        RentalItemLend(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* AccountID, const char* CharID, const int32_t nRentalIndex, 
            const int32_t nItemNumber, int16_t* nRet) noexcept(false);

        ~RentalItemLend();
    };

    class RentalItemRegister : public detail::StoredProcedure
    {
    public:
        RentalItemRegister();
        RentalItemRegister(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* charID, const char* AccountID, const int16_t sRentalTime, 
            const int32_t nItemID, const int16_t sDurability, const int32_t nMoney, 
            const uint8_t bGameBangType, const uint8_t bItemType, const uint8_t bItemClass, 
            const int64_t nSerialNumber, int32_t* nRet_Index, int16_t* nRet) noexcept(false);

        ~RentalItemRegister();
    };

    class ResetLoyaltyMonthly : public detail::StoredProcedure
    {
    public:
        ResetLoyaltyMonthly();
        ResetLoyaltyMonthly(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class SkillshortcutLoad : public detail::StoredProcedure
    {
    public:
        SkillshortcutLoad();
        SkillshortcutLoad(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strCharID) noexcept(false);
    };

    class SkillshortcutSave : public detail::StoredProcedure
    {
    public:
        SkillshortcutSave();
        SkillshortcutSave(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strCharID, const int16_t nCount, const char* strSkillData) noexcept(false);
    };

    class UpdateBattleHero : public detail::StoredProcedure
    {
    public:
        UpdateBattleHero();
        UpdateBattleHero(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strCharID, const char* strNation, const char* strClass, 
            const char* strAchievement, const int16_t nIndex) noexcept(false);
    };

    class UpdateBattleResult : public detail::StoredProcedure
    {
    public:
        UpdateBattleResult();
        UpdateBattleResult(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* UserId, const uint8_t byNation, const int16_t index) noexcept(false);
    };

    class UpdateEditorItemData : public detail::StoredProcedure
    {
    public:
        UpdateEditorItemData();
        UpdateEditorItemData(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* charid, const char* accountid, const char* opid, 
            const char* opip, const int16_t sPos, const int32_t nItemID1, 
            const int32_t nItemID2, const uint8_t byType, const int16_t sDBIndex) noexcept(false);
    };

    class UpdateKnights : public detail::StoredProcedure
    {
    public:
        UpdateKnights();
        UpdateKnights(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, const uint8_t Type, const char* UserId, 
            const int16_t KnightsIndex, const uint8_t Domination) noexcept(false);

        ~UpdateKnights();
    };

    class UpdateKnightsAlliance : public detail::StoredProcedure
    {
    public:
        UpdateKnightsAlliance();
        UpdateKnightsAlliance(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const int16_t shAlliancIndex, const int16_t shKnightsIndex, 
            const uint8_t byEmptyIndex, const uint8_t bySiegeFlag) noexcept(false);
    };

    class UpdateKnightsMark : public detail::StoredProcedure
    {
    public:
        UpdateKnightsMark();
        UpdateKnightsMark(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            int16_t* nRet, const int16_t IDNum, const int16_t MarkLen, 
            const std::vector<uint8_t>& KnightMark) noexcept(false);

        ~UpdateKnightsMark();
    };

    class UpdateKnightsWar : public detail::StoredProcedure
    {
    public:
        UpdateKnightsWar();
        UpdateKnightsWar(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const uint8_t byType, const int16_t shWhite, const int16_t shBlue) noexcept(false);
    };

    class UpdatePersonalRank : public detail::StoredProcedure
    {
    public:
        UpdatePersonalRank();
        UpdatePersonalRank(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };

    class UpdatePremiumServiceUser : public detail::StoredProcedure
    {
    public:
        UpdatePremiumServiceUser();
        UpdatePremiumServiceUser(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(int* returnValue, 
            const char* AccountID, const int16_t Days) noexcept(false);

        ~UpdatePremiumServiceUser();
    };

    class UpdateSavedMagic : public detail::StoredProcedure
    {
    public:
        UpdateSavedMagic();
        UpdateSavedMagic(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* strCharID, const int32_t Skill1, const int16_t During1, 
            const int32_t Skill2, const int16_t During2, const int32_t Skill3, 
            const int16_t During3, const int32_t Skill4, const int16_t During4, 
            const int32_t Skill5, const int16_t During5, const int32_t Skill6, 
            const int16_t During6, const int32_t Skill7, const int16_t During7, 
            const int32_t Skill8, const int16_t During8, const int32_t Skill9, 
            const int16_t During9, const int32_t Skill10, const int16_t During10) noexcept(false);
    };

    class UpdateSiege : public detail::StoredProcedure
    {
    public:
        UpdateSiege();
        UpdateSiege(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t sCastleIndex, const int16_t sKnightsIndex, const uint8_t byWarType, 
            const uint8_t byUpdateType, const uint8_t byWarDay, const uint8_t byWarTime, 
            const uint8_t byWarMinute) noexcept(false);
    };

    class UpdateSiegeChallenger : public detail::StoredProcedure
    {
    public:
        UpdateSiegeChallenger();
        UpdateSiegeChallenger(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t sCastleIndex, const char* strChallengerList) noexcept(false);
    };

    class UpdateSiegeChallenger2 : public detail::StoredProcedure
    {
    public:
        UpdateSiegeChallenger2();
        UpdateSiegeChallenger2(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t sCastleIndex, const int16_t sKnights_1, const int16_t sKnights_2, 
            const int16_t sKnights_3, const int16_t sKnights_4, const int16_t sKnights_5, 
            const int16_t sKnights_6, const int16_t sKnights_7, const int16_t sKnights_8, 
            const int16_t sKnights_9, const int16_t sKnights_10, const char* strChallengerList) noexcept(false);
    };

    class UpdateSiegeDecideChallenger : public detail::StoredProcedure
    {
    public:
        UpdateSiegeDecideChallenger();
        UpdateSiegeDecideChallenger(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const int16_t sCastleIndex, const int16_t sKnights_1, const int16_t sKnights_2, 
            const int16_t sKnights_3, const int16_t sKnights_4, const int16_t sKnights_5, 
            const int16_t sKnights_6, const int16_t sKnights_7, const int16_t sKnights_8, 
            const int16_t sKnights_9, const int16_t sKnights_10) noexcept(false);
    };

    class UpdateUserData : public detail::StoredProcedure
    {
    public:
        UpdateUserData();
        UpdateUserData(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* id, const uint8_t Nation, const uint8_t Race, 
            const int16_t Class, const uint8_t HairColor, const uint8_t Rank, 
            const uint8_t Title, const uint8_t Level, const int32_t Exp, 
            const int32_t Loyalty, const uint8_t Face, const uint8_t City, 
            const int16_t Knights, const uint8_t Fame, const int16_t Hp, 
            const int16_t Mp, const int16_t Sp, const uint8_t Str, 
            const uint8_t Sta, const uint8_t Dex, const uint8_t Intel, 
            const uint8_t Cha, const uint8_t Authority, const uint8_t Points, 
            const int32_t Gold, const uint8_t Zone, const int16_t Bind, 
            const int32_t PX, const int32_t PZ, const int32_t PY, 
            const int32_t dwTime, const int16_t QuestTotal, const std::vector<uint8_t>& strSkill, 
            const std::vector<uint8_t>& strItem, const std::vector<uint8_t>& strSerial, const std::vector<uint8_t>& strQuest, 
            const int32_t MannerPoint, const int32_t LoyaltyMonthly) noexcept(false);
    };

    class UpdateWarehouse : public detail::StoredProcedure
    {
    public:
        UpdateWarehouse();
        UpdateWarehouse(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute(
            const char* accountid, const int32_t Money, const int32_t dwTime, 
            const std::vector<uint8_t>& strItem, const std::vector<uint8_t>& strSerial) noexcept(false);
    };

    class UserKnightsRatingUpdate : public detail::StoredProcedure
    {
    public:
        UserKnightsRatingUpdate();
        UserKnightsRatingUpdate(std::shared_ptr<nanodbc::connection> conn);

        static const std::string& Query();

        static modelUtil::DbType DbType();

        std::weak_ptr<nanodbc::result> execute() noexcept(false);
    };
}
 
#endif // STOREDPROC_STOREDPROC_H