function newClass(constructor)
    local methods = { }
    local MT = {__index = methods}

    local call = function(self, ...)
        local obj = constructor(...)
        if not obj then
            return nil
        end

        return setmetatable(obj, MT)
    end

    return setmetatable(methods, {__call = call})
end


Creature = newClass(function(param)
    if type(param) == 'string' then
        local cid = getPlayerByNameWildcard(param)
        if not cid then
            return nil
        end
        return {cid = cid}
    elseif type(param) == 'number' then
        if not getPlayerGUID(param) then
            return nil
        end
        return {cid = param}
    else
        return nil
    end
end)

-- inherit all the metamethods of Creature
Player, Npc, Monster = Creature, Creature, Creature

Game = {}

function Creature:getId()
    return self.cid
end

function Creature:getName()
    return getCreatureName(self.cid)
end

function Creature:getHealth()
    return getCreatureHealth(self.cid)
end

function Creature:getMaxHealth()
    return getCreatureMaxHealth(self.cid)
end

function Creature:getMana()
    return getCreatureMana(self.cid)
end

function Creature:getMaxMana()
    return getCreatureMaxMana(self.cid)
end

function Creature:getPosition()
    return getCreaturePosition(self.cid)
end

function Creature:getLookDir()
    return getCreatureLookDirection(self.cid)
end

function Creature:getSkull()
    return getCreatureSkullType(self.cid)
end

function Creature:getMaster()
    return getCreatureMaster(self.cid)
end

function Creature:getSummons()
    return getCreatureSummons(self.cid)
end

function Creature:getOutfit()
    return getCreatureOutfit(self.cid)
end

function Creature:getHiddenHealth()
    return getCreatureHideHealth(self.cid)
end

function Creature:setHideHealth(hide)
    return doCreatureSetHideHealth(self.cid, hide)
end

function Creature:getSpeakType()
    return getCreatureSpeakType(self.cid)
end

function Creature:setSpeakType(type)
    return doCreatureSetSpeakType(self.cid, type)
end

function Creature:getLookDirection()
    return getCreatureLookDirection(self.cid)
end

function Creature:getCreatureStorage(key)
    return getCreatureStorage(self.cid, key)
end

function Creature:isCreature()
    return isCreature(self.cid)
end

function Creature:say(text, type, ghost, cid, pos)
    -- doCreatureSay(uid, text, type[, ghost = false[, cid = 0[, pos]]])
    return doCreatureSay(self.cid, text, type, ghost, cid, pos)
end

function Creature:setCreatureStorage(key, value)
    return doCreatureSetStorage(self.cid, key, value)
end

function Creature:getStorage(key)
    return getStorage(key)
end

function Creature:setStorage(key, value)
    return doSetStorage(key, value)
end

-- creature, npc, player, item
function Creature:sendMagicEffect(type, player)
    -- doSendMagicEffect(pos, type[, player])
    return doSendMagicEffect(self:getPosition(), type, player)
end

--------------------------------------




function Npc:isNpc()
    return isNpc(self.cid)
end

function Monster:isMonster()
    return isMonster(self.cid)
end

------------------------------------------
-- Player
function Player:isPlayer()
    return isPlayer(self.cid)
end

function Player:getLevel()
    return getPlayerLevel(self.cid)
end

function Player:getExperience()
    return getPlayerExperience(self.cid)
end

function Player:getMagicLevel(ignoreBuffs)
    -- getPlayerMagLevel(cid [, ignoreBuffs = false])
    return getPlayerMagLevel(self.cid, false)
end

function Player:getSpentMana()
    return getPlayerSpentMana(self.cid)
end

function Player:getFood()
    return getPlayerFood(self.cid)
end

function Player:getAccess()
    return getPlayerAccess(self.cid)
end

function Player:getGhostAccess()
    return getPlayerGhostAccess(self.cid)
end

function Player:getSkillLevel(skillid)
    return getPlayerSkillLevel(self.cid, skillid)
end

function Player:getSkillTries(skillid)
    return getPlayerSkillTries(self.cid, skillid)
end

function Player:getTown()
    return getPlayerTown(self.cid)
end

function Player:getVocation()
    return getPlayerVocation(self.cid)
end

function Player:getIp()
    return getPlayerIp(self.cid)
end

function Player:getRequiredMana(magicLevel)
    return getPlayerRequiredMana(self.cid, magicLevel)
end

function Player:getRequiredSkillTries(skillId, skillLevel)
    return getPlayerRequiredSkillTries(self.cid, skillId, skillLevel)
end

function Player:getItemCount(itemid, subtype)
    return getPlayerItemCount(self.cid, itemid, subType)
end

function Player:getMoney()
    return getPlayerMoney(self.cid)
end

function Player:getSoul()
    return getPlayerSoul(self.cid)
end

function Player:getFreeCap()
    return getPlayerFreeCap(self.cid)
end

function Player:getLight()
    return getPlayerLight(self.cid)
end

function Player:getSlotItem(slot)
    return getPlayerSlotItem(self.cid, slot)
end

function Player:getWeapon(ignoreAmmo)
    -- getPlayerWeapon(cid [, ignoreAmmo = false])
    return getPlayerWeapon(self.cid, ignoreAmmo)
end

function Player:getItemById(deepSearch, itemId, subType)
    -- getPlayerItemById(cid, deepSearch, itemId[, subType = -1])
    return getPlayerItemById(self.cid, deepSearch, itemId, subType)
end

function Player:getDepotItems(depotid)
    return getPlayerDepotItems(self.cid, depotid)
end

function Player:getGuildId()
    return getPlayerGuildId(self.cid)
end

function Player:getGuildName()
    return getPlayerGuildName(self.cid)
end

function Player:getGuildRankId()
    return getPlayerGuildRankId(self.cid)
end

function Player:getGuildRank()
    return getPlayerGuildRank(self.cid)
end

function Player:getGuildNick()
    return getPlayerGuildNick(self.cid)
end

function Player:getGuildLevel()
    return getPlayerGuildLevel(self.cid)
end

function Player:getGuid()
    return getPlayerGUID(self.cid)
end

function Player:getNameDescription()
    return getPlayerNameDescription(self.cid)
end

function Player:setNameDescription(desc)
    return doPlayerSetNameDescription(self.cid, desc)
end

function Player:getSpecialDescription()
    return getPlayerSpecialDescription(self.cid)
end

function Player:setSpecialDescription(desc)
    return doPlayerSetSpecialDescription(self.cid, desc)
end

function Player:getAccountId()
    return getPlayerAccountId(self.cid)
end

function Player:getAccount()
    return getPlayerAccount(self.cid)
end

function Player:getFlagValue(flag)
    return getPlayerFlagValue(self.cid, flag)
end

function Player:getCustomFlagValue(flag)
    return getPlayerCustomFlagValue(self.cid, flag)
end

function Player:getPromotion()
    return getPlayerPromotionLevel(self.cid)
end

function Player:setPromotion(level)
    return doPlayerSetPromotionLevel(self.cid, level)
end

function Player:getGroupId()
    return getPlayerGroupId(self.cid)
end

function Player:setGroupId(newGroupId)
    return doPlayerSetGroupId(self.cid, newGroupId)
end

function Player:sendOutfitWindow()
    return doPlayerSendOutfitWindow(self.cid)
end

function Player:learnInstantSpell(name)
    return doPlayerLearnInstantSpell(self.cid, name)
end

function Player:unlearnInstantSpell(name)
    return doPlayerUnlearnInstantSpell(self.cid, name)
end

function Player:getLearnedInstantSpell(name)
    return getPlayerLearnedInstantSpell(self.cid, name)
end

function Player:getInstantSpellCount()
    return getPlayerInstantSpellCount(self.cid)
end

function Player:getInstantSpellInfo(index)
    return type(index) == 'number' and getPlayerInstantSpellInfo(self.cid, index) or getInstantSpellInfo(self.cid, index)
end





function Game.getUsersInChannel(channelId)
    return getChannelUsers(channelId)
end

function Game.getOnline()
    return getPlayersOnline()
end

function Tile:getTileInfo(pos)
    return getTileInfo(pos and pos or self:getPosition())
end

-- universal
function Position:getThingFromPos(displayError)
    -- getThingFromPos(pos[, displayError = true])
    return getThingFromPos(self:getPosition(), displayError)
end

-- creature, npc, player, item
function Thing:
    return getThing(self.uid)
end

function Thing:
    return doTileQueryAdd(self.uid, pos[, flags[, displayError = true]])
end

function x:
    return doItemRaidUnref(self.uid)
end

-- creature, npc, player, item
function Thing:getPosition()
    return getThingPosition(self.cid)
end

function Position:
    return getTileItemById(pos, itemId[, subType = -1])
end

function Position:
    return getTileItemByType(pos, type)
end

function Position:
    return getTileThingByPos(pos)
end

function Position:
    return getTopCreature(pos)
end

function Item:remove(count)
    -- doRemoveItem(uid[, count])
    return doRemoveItem(self.cid, count or 1)
end

function Player:feed(food)
    return doPlayerFeed(self.cid, food)
end

function Player:sendCancelMessage(text, returnValue)
    return returnValue and doPlayerSendDefaultCancel(self.cid, returnValue) or doPlayerSendCancel(self.cid, text)
end

function x:
    return getSearchString(fromPosition, toPosition[, fromIsCreature = false[, toIsCreature = false]])
end

function x:getClosestFreePosition(targetpos, extended, ignoreHouse)
    -- getClosestFreeTile(cid, targetpos[, extended = false[, ignoreHouse = true]])
    return getClosestFreeTile(self.cid, targetpos, extended, ignoreHouse)
end

-- universal
function Thing:teleportTo(newpos, pushmove)
    return doTeleportThing(self.cid, newpos, pushmove)
end


function Item:transform(newId, count)
    return doTransformItem(self.cid, newId, count)
end



-- creature, npc, player, item
function Creature:sendMagicEffect(type, player)
    -- doSendMagicEffect(pos, type[, player])
    return doSendMagicEffect(self:getPosition(), type, player)
end

-- creature, npc, player, item
function Creature:sendDistanceEffect(toPos, type, player)
    -- doSendDistanceShoot(fromPos, toPos, type[, player])
    return doSendDistanceShoot(self:getPosition(), toPos, type, player)
end

-- creature, npc, player, item, position
function Creature:animateText(text, color, player)
    -- doSendAnimatedText(pos, text, color[, player])
    return doSendAnimatedText(self:getPosition(), text, color, player)
end

function Player:addSkillTry(skillid, n, useMultiplier)
    -- doPlayerAddSkillTry(cid, skillid, n[, useMultiplier])
    return doPlayerAddSkillTry(self.cid, skillid, n[, useMultiplier])
end

-- npc, creature, player
function Creature:addHealth(health, hitEffect, hitColor, force)
    -- doCreatureAddHealth(cid, health[, hitEffect[, hitColor[, force]]])
    return doCreatureAddHealth(self.cid, health, hitEffect, hitColor, force)
end

function Creature:addMana(mana)
    return doCreatureAddMana(self.cid, mana)
end

-- creature, npc, player
function Creature:setMaxHealth(health)
    return setCreatureMaxHealth(self.cid, health)
end

function Creature:setMaxMana(mana)
    return setCreatureMaxMana(self.cid, mana)
end

function Player:setMaxCap(cap)
    return doPlayerSetMaxCapacity(self.cid, cap)
end

function Player:addManaSpent(amount, useMultiplier)
    -- doPlayerAddSpentMana(cid, amount[, useMultiplier])
    return doPlayerAddSpentMana(self.cid, amount, useMultiplier)
end

function Player:addSoul(soul)
    return doPlayerAddSoul(self.cid, soul)
end

function Player:addItem(itemid, count, canDropOnMap)
    -- doPlayerAddItem(cid, itemid[, count/subtype[, canDropOnMap]])
    -- doPlayerAddItem(cid, itemid[, count[, canDropOnMap[, subtype]]])
    -- Returns uid of the created item
    return doPlayerAddItem(self.cid, itemid, count, canDropOnMap)
end

function Player:addItemEx(uid, canDropOnMap)
    -- doPlayerAddItemEx(cid, uid[, canDropOnMap = FALSE])
    return doPlayerAddItemEx(self.cid, uid, canDropOnMap)
end

function Player:sendTextMessage(MessageClasses, message)
    return doPlayerSendTextMessage(self.cid, MessageClasses, message)
end

function Player:sendChannelMessage(channel, SpeakClasses, message, author)
    return doPlayerSendChannelMessage(self.cid, author, message, SpeakClasses, channel)
end

function Player:sendToChannel(targetId, SpeakClasses, message, channel, time_)
    -- doPlayerSendToChannel(cid, targetId, SpeakClasses, message, channel[, time])
    return doPlayerSendToChannel(self.cid, targetId, SpeakClasses, message, channel, time_)
end

function Player:addMoney(money)
    return doPlayerAddMoney(self.cid, money)
end

function Player:removeMoney(money)
    return doPlayerRemoveMoney(self.cid, money)
end

function Player:transferMoneyTo(target, money)
    return doPlayerTransferMoneyTo(self.cid, target, money)
end

-- universal
function x:showTextDialog(itemid, text)
    return doShowTextDialog(self.cid, itemid, text)
end


function Item:decay()
    return doDecayItem(self.cid)
end

function x:
    return doCreateItem(itemid[, type/count], pos)
    --return Returns uid of the created item, only works on tiles.
end

function x:
    return doCreateItemEx(itemid[, count/subType = -1])
end

function x:
    return doTileAddItemEx(pos, uid)
end

function x:
    return doAddContainerItemEx(uid, virtuid)


    return doRelocate(pos, posTo[, creatures = true])
    --return Moves all moveable objects from pos to posTo
end

function x:
    return doCleanTile(pos[, forceMapLoaded = false])
end

function x:
    return doCreateTeleport(itemid, topos, createpos)
end

function Game.createMonster(name, pos, displayError)
    -- doCreateMonster(name, pos[, displayError = true])
    return doCreateMonster(name, pos, displayError)
end

function Game.createNpc(name, pos, displayError)
    -- doCreateNpc(name, pos[, displayError = true])
    return doCreateNpc(name, pos, displayError)
end

function Game.createMonster(name)
    return doSummonMonster(self.cid, name)
end

function x:
    return doConvinceCreature(self.cid, target)
end

function x:
    return getMonsterTargetList(self.cid)
end

function x:
    return getMonsterFriendList(self.cid)
end

function x:
    return doMonsterSetTarget(self.cid, target)
end

function x:
    return doMonsterChangeTarget(self.cid)
end

function x:
    return getMonsterInfo(name)
end

function x:
    return doAddCondition(self.cid, condition)
end

function x:
    return doRemoveCondition(self.cid, type[, subId])
end

function x:
    return doRemoveConditions(self.cid[, onlyPersistent])
end

function Creature:
    return doRemoveCreature(self.cid[, forceLogout = true])
end

function Creature:
    return doMoveCreature(self.cid, direction)
end

function Player:
    return doPlayerSetPzLocked(self.cid, locked)
end

function Player:
    return doPlayerSetTown(self.cid, townid)
end

function Creature:
    return doPlayerSetVocation(self.cid,voc)
end

function Player:
    return doPlayerRemoveItem(self.cid, itemid[, count[, subType]])
end

function Player:
    return doPlayerAddExperience(self.cid, amount)
end

function Player:
    return doPlayerSetGuildId(self.cid, id)
end

function Player:
    return doPlayerSetGuildLevel(self.cid, level[, rank])
end

function Player:
    return doPlayerSetGuildNick(self.cid, nick)
end

function Player:
    return doPlayerAddOutfit(self.cid, looktype, addon)
end

function Player:
    return doPlayerRemoveOutfit(self.cid, looktype[, addon = 0])
end

function Player:
    return doPlayerAddOutfitId(self.cid, outfitId, addon)
end

function Player:
    return doPlayerRemoveOutfitId(self.cid, outfitId[, addon = 0])
end

function Creature:
    return canPlayerWearOutfit(self.cid, looktype[, addon = 0])
end

function Creature:
    return canPlayerWearOutfitId(self.cid, outfitId[, addon = 0])
end

function Creature:
    return doSetCreatureLight(self.cid, lightLevel, lightColor, time)
end

function Creature:
    return getCreatureCondition(self.cid, condition[, subId])
end

function Creature:
    return doCreatureSetDropLoot(self.cid, doDrop)
end

function Player:
    return getPlayerLossPercent(self.cid, lossType)
end

function Player:
    return doPlayerSetLossPercent(self.cid, lossType, newPercent)
end

function Player:
    return doPlayerSetLossSkill(self.cid, doLose)
end

function Player:
    return getPlayerLossSkill(self.cid)
end

function Player:
    return doPlayerSwitchSaving(self.cid)
end

function Player:
    return doPlayerSave(self.cid[, shallow = false])
end

function Player:
    return isPlayerPzLocked(self.cid)
end

function Player:
    return isPlayerSaving(self.cid)
end

function Creature:
    return isCreature(self.cid)
end

function Container:
    return isContainer(uid)
end

function Thing:
    return isMovable(uid)
end

function Creature:
    return getCreatureByName(name)
end

function Player:
    return getPlayerByGUID(guid)
end

function Player:
    return getPlayerByNameWildcard(name~[, ret = false])
end

function Player:
    return getPlayerGUIDByName(name[, multiworld = false])
end

function Player:
    return getPlayerNameByGUID(guid[, multiworld = false[, displayError = true]])
end

function Creature:
    return registerCreatureEvent(uid, eventName)
end

function Container:
    return getContainerSize(uid)
end

function Container:
    return getContainerCap(uid)
end

function Container:
    return getContainerItem(uid, slot)
end

function Container:
    return doAddContainerItem(uid, itemid[, count/subType])
end

function House:
    return getHouseInfo(houseId)
end

function House:
    return getHouseAccessList(houseid, listId)
end

function House:
    return getHouseByPlayerGUID(playerGUID)
end

function House:
    return getHouseFromPos(pos)
end

function House:
    return setHouseAccessList(houseid, listid, listtext)
end

function House:
    return setHouseOwner(houseId, owner[, clean])
end

function Game:
    return getWorldType()
end

function Game:
    return setWorldType(type)
end

function Game:
    return getWorldTime()
end

function Game:
    return getWorldLight()
end

function Game:getWorldCreatures(t)
    --0 players, 1 monsters, 2 npcs, 3 all
    return not t and getWorldCreatures(3) or getWorldCreatures(t)
end

function Game:
    return getWorldUpTime()
end

function Guild:
    return getGuildId(guildName)
end

function Guild:
    return getGuildMotd(guildId)
end

function Player:
    return getPlayerSex(self.cid[, full = false])
end

function Player:
    return doPlayerSetSex(self.cid, newSex)
end

function Combat:
    return createCombatArea({area}[, {extArea}])
end

function Condition:
    return createConditionObject(type[, ticks[, buff[, subId]]])
end

function Combat:
    return setCombatArea(combat, area)
end

function Combat:
    return setCombatCondition(combat, condition)
end

function Combat:
    return setCombatParam(combat, key, value)
end

function Condition:
    return setConditionParam(condition, key, value)
end

function Condition:
    return addDamageCondition(condition, rounds, time, value)
end

function Condition:
    return addOutfitCondition(condition, outfit)
end

function Combat:
    return setCombatCallBack(combat, key, function_name)
end

function Combat:
    return setCombatFormula(combat, type, mina, minb, maxa, maxb[, minl, maxl[, minm, maxm[, minc[, maxc]]]])
end

function Condition:
    return setConditionFormula(combat, mina, minb, maxa, maxb)
end

function Combat:
    return doCombat(self.cid, combat, param)
end

function Combat:
    return createCombatObject()
end

function Combat:
    return doCombatAreaHealth(self.cid, type, pos, area, min, max, effect)
end

function Combat:
    return doTargetCombatHealth(self.cid, target, type, min, max, effect)
end

function Combat:
    return doCombatAreaMana(self.cid, pos, area, min, max, effect)
end

function Combat:
    return doTargetCombatMana(self.cid, target, min, max, effect)
end

function Combat:
    return doCombatAreaCondition(self.cid, pos, area, condition, effect)
end

function Combat:
    return doTargetCombatCondition(self.cid, target, condition, effect)
end

function Combat:
    return doCombatAreaDispel(self.cid, pos, area, type, effect)
end

function Combat:
    return doTargetCombatDispel(self.cid, target, type, effect)
end

function Creature:
    return doChallengeCreature(self.cid, target)
end

function Variant:
    return numberToVariant(number)
end

function Variant:
    return stringToVariant(string)
end

function Variant:
    return positionToVariant(pos)
end

function Variant:
    return targetPositionToVariant(pos)
end

function Variant:
    return variantToNumber(var)
end

function Variant:
    return variantToString(var)
end

function Variant:
    return variantToPosition(var)
end

function Creature:
    return doChangeSpeed(self.cid, delta)
end

function Creature:
    return doCreatureChangeOutfit(self.cid, outfit)
end

function Creature:
    return doSetMonsterOutfit(self.cid, name, time)
end

function Creature:
    return doSetItemOutfit(self.cid, item, time)
end

function Creature:
    return doSetCreatureOutfit(self.cid, outfit, time)
end

function Creature:
    return getCreatureOutfit(self.cid)
end

function Creature:
    return getCreatureLastPosition(self.cid)
end

function Creature:
    return getCreatureName(self.cid)
end

function Creature:
    return getCreatureSpeed(self.cid)
end

function Creature:
    return getCreatureBaseSpeed(self.cid)
end

function Creature:
    return getCreatureTarget(cid)
end

function Game:
    return isSightClear(fromPos, toPos, floorCheck)
end

function Game:
    return isInArray(array, value[, caseSensitive = false])
end

function Game:
    return addEvent(callback, delay, ...)
end

function Game:
    return stopEvent(eventid)
end

function Player:
    return getPlayersByAccountId(accId)
end

function Game:
    return getAccountIdByName(name)
end

function Game:
    return getAccountByName(name)
end

function Game:
    return getAccountIdByAccount(accName)
end

function Game:
    return getAccountByAccountId(accId)
end

function Game:
    return getIpByName(name)
end

function Player:
    return getPlayersByIp(ip[, mask = 0xFFFFFFFF])
end

function Player:
    return doPlayerPopupFYI(self.cid, message)
end

function Player:
    return doPlayerSendTutorial(self.cid, id)
end

function Player:
    return doPlayerSendMailByName(name, item[, town[, actor]])
end

function Player:
    return doPlayerAddMapMark(self.cid, pos, type[, description])
end

function Player:
    return doPlayerAddPremiumDays(self.cid, days)
end

function Player:
    return getPlayerPremiumDays(self.cid)
end

function Creature:
    return doCreatureSetLookDirection(self.cid, dir)
end

function Creature:
    return getCreatureSkullType(self.cid[, target])
end

function Creature:
    return doCreatureSetSkullType(self.cid, skull)
end

function Player:
    return getPlayerSkullEnd(self.cid)
end

function Player:
    return doPlayerSetSkullEnd(self.cid, time, type)
end

function Player:
    return getPlayerBalance(self.cid)
end

function Player:
    return getPlayerBlessing(self.cid, blessing)
end

function Player:
    return doPlayerAddBlessing(self.cid, blessing)
end

function Player:
    return getPlayerStamina(self.cid)
end

function Player:
    return doPlayerSetStamina(self.cid, minutes)
end

function Player:
    return doPlayerAddStamina(self.cid, minutes)
end

function Player:
    return doPlayerSetBalance(self.cid, balance)
end

function Creature:
    return getCreatureNoMove(self.cid)
end

function Creature:
    return doCreatureSetNoMove(self.cid, block)
end

function Creature:
    return getPlayerIdleTime(self.cid)
end

function Creature:
    return doPlayerSetIdleTime(self.cid, amount)
end

function Player:
    return getPlayerLastLoad(self.cid)
end

function Player:
    return getPlayerLastLogin(self.cid)
end

function Player:
    return getPlayerAccountManager(self.cid)
end

function Player:
    return getPlayerRates(self.cid)
end

function Player:
    return doPlayerSetRate(self.cid, type, value)
end

function Player:
    return getPlayerPartner(self.cid)
end

function Player:
    return doPlayerSetPartner(self.cid, guid)
end

function Player:
    return getPlayerParty(self.cid)
end

function Player:
    return doPlayerJoinParty(self.cid, lid)
end

function Creature:
    return getPartyMembers(lid)
end

function Creature:
    return getCreatureMaster(self.cid)
end

function Creature:
    return getCreatureSummons(cid)
end

function Town:
    return getTownId(townName)
end

function Town:
    return getTownName(townId)
end

function Town:
    return getTownTemplePosition(townId[, displayError])
end

function Town:
    return getTownHouses(townId)
end

function Game:
    return getSpectators(centerPos, rangex, rangey[, multifloor = false])
end

function Game:
    return getVocationInfo(id)
end

function Group:
    return getGroupInfo(id)
end

function Game:
    return getWaypointList()
end

function Game:
    return getTalkActionList()
end

function Game:
    return getExperienceStageList()
end

function Item:
    return getItemIdByName(name[, displayError = true])
end

function Item:
    return getItemInfo(itemid)
end

function Item:
    return getItemAttribute(uid, key)
end

function Item:
    return doItemSetAttribute(uid, key, value)
end

function Item:
    return doItemEraseAttribute(uid, key)
end

function Item:
    return getItemWeight(uid[, precise = true])
end

function Item:
    return hasItemProperty(uid)
end


function Player:
    hasPlayerClient(self.cid)
end

function Game:
    return isIpBanished(ip[, mask])
end

function Player:
    return isPlayerBanished(name/guid, type)
end

function Game:
    return isAccountBanished(accountId[, playerId])
end

function Game:
    return doAddIpBanishment(...)
end

function Game:
    return doAddPlayerBanishment(...)
end

function Game:
    return doAddAccountBanishment(...)
end

function Game:
    return doAddNotation(...)
end

function Game:
    return doAddStatement(...)
end

function Game:
    return doRemoveIpBanishment(ip[, mask])
end

function Game:
    return doRemovePlayerBanishment(name/guid, type)
end

function Game:
    return doRemoveAccountBanishment(accountId[, playerId])
end

function Game:
    return doRemoveNotations(accountId[, playerId])
end

function Game:
    return doRemoveStatements(name/guid[, channelId])
end

function Game:
    return getNotationsCount(accountId[, playerId])
end

function Game:
    return getStatementsCount(name/guid[, channelId])
end

function Game:
    return getBanData(value[, type[, param]])
end

function Game:
    return getBanReason(id)
end

function Game:
    return getBanAction(id)
end

function Game:
    return getBanList(type[, value[, param]])
end

function Game:
    return getExperienceStage(level)
end

function Game:
    return getDataDir()
end

function Game:
    return getLogsDir()
end

function Game:
    return getConfigFile()
end

function Game:
    return getConfigValue(key)
end

function Game:
    return getModList()
end

function Game:
    return getHighscoreString(skillId)
end

function Game:
    return getWaypointPosition(name)
end

function Game:
    return doWaypointAddTemporial(name, pos)
end

function Game:
    return getGameState()
end

function Game:
    return doSetGameState(id)
end

function Game:
    return doExecuteRaid(name)
end

function Creature:
    return doCreatureExecuteTalkAction(self.cid, text[, ignoreAccess[, channelId]])
end

function Game:
    return doReloadInfo(id[, self.cid])
end

function Game:
    return doSaveServer()
end

function House:
    return doCleanHouse(houseId)
end

function Game:
    return doCleanMap()
end

function Game:
    return doRefreshMap()
end

function Game:
    return doUpdateHouseAuctions()
end

function Game:
    return loadmodlib(lib)
end

function Game:
    return domodlib(lib)
end

function Game:
    return dodirectory(dir)
end